Subversion Repositories Kolibri OS

// memman.cpp : Defines the entry point for the console application.

//

#include "kosSyst.h"

#include "mcsmemm.h"

void * __cdecl operator new ( size_t count, size_t element_size )

{

	return allocmem( (Dword)(count * element_size) );

}

void * __cdecl operator new [] ( size_t amount )

{

	return allocmem( (Dword)amount );

}

void * __cdecl operator new ( size_t amount )

{

	return allocmem( (Dword)amount );

}

void __cdecl operator delete ( void *pointer )

{

	if ( pointer != NULL ) freemem( pointer );

}

void __cdecl operator delete [] ( void *pointer )

{

	if ( pointer != NULL ) freemem( pointer );

}

Byte *allocmem( Dword reqsize )

{

	__asm

	{

		mov eax, 68

		mov ebx, 12

		mov ecx, reqsize

		int 0x40

	}

}

Dword freemem( void *vaddress )

{

	__asm

	{

		mov eax, 68

		mov ebx, 13

		mov ecx, vaddress

		int 0x40

	}

}

/*

//

Dword mmMutex = FALSE;

MemBlock *rootfree = NULL;

MemBlock *rootuser = NULL;

bool mmInitialized = false;

Byte *mmHeapTop = NULL;

//

Byte * AllocMemFromSystem( Dword reqSize )

{

	Byte *result;

	sProcessInfo pInfo;

	//

	if ( mmInitialized )

	{

		result = mmHeapTop;

	}

	else

	{

		//

		kos_ProcessInfo( &pInfo );

		//

		result = (Byte *)(pInfo.processInfo.used_memory + 1);

		//

		mmInitialized = true;

	}

	//

	if ( ! kos_ApplicationMemoryResize( ((Dword)result) + reqSize ) )

	{

		result = NULL;

	}

	//

	mmHeapTop = result + reqSize;

	//

	return result;

}

//

Byte *allocmem( Dword reqsize )

{

  MemBlock *BlockForCheck;

  MemBlock *LastKnownGood;

  Dword tail;

  Byte *address;

  //ïîäðîâíÿåì ðàçìåð

  if( ( tail = reqsize % SIZE_ALIGN ) != 0 )

  {

    reqsize += SIZE_ALIGN - tail;

  }

  LastKnownGood = NULL;

  // æä¸ì îñâîáîæäåíèÿ ìüþòåêñà

  while ( rtlInterlockedExchange( &mmMutex, TRUE ) )

  {

	  //

	  kos_Pause( 1 );

  }

  //èùåì ïîäõîäÿùèé ñâîáîäíûé áëîê

  if( rootfree != NULL )

  {

    for ( BlockForCheck = rootfree; ; BlockForCheck = BlockForCheck->Next )

    {

      if ( BlockForCheck->Size >= reqsize )

      {

        //íàøëè

        if ( LastKnownGood != NULL )

        {

          if ( LastKnownGood->Size >= BlockForCheck->Size )

            LastKnownGood = BlockForCheck;

        }

        else

          LastKnownGood = BlockForCheck;

        if ( LastKnownGood->Size == reqsize )

          break;

      }

      if ( BlockForCheck->Next == NULL )

        break;

    }

  }

  if ( LastKnownGood != NULL )

  {

    //ïðîâåðèì íàéäåííûé áëîê íà âîçìîæíîñòü äåëåíèÿ

    tail = LastKnownGood->Size - reqsize;

    if ( tail >= ( sizeof(MemBlock) + SIZE_ALIGN ) )

    {

      //áóäåì ðàçáèâàòü

      BlockForCheck = (MemBlock *)( ( (Byte *)LastKnownGood ) + tail );

      BlockForCheck->Size = reqsize;

      //âñòàâèì çàíÿòûé áëîê â íà÷àëî ñïèñêà çàíàòûõ áëîêîâ

      if( rootuser != NULL )

      {

        BlockForCheck->Next = rootuser;

        rootuser->Previous = BlockForCheck;

        BlockForCheck->Previous = NULL;

        rootuser = BlockForCheck;

      }

      else

      {

        rootuser = BlockForCheck;

        BlockForCheck->Next = NULL;

        BlockForCheck->Previous = NULL;

      }

      //èçìåíèì ðàçìåð îñòàâøåéñÿ ÷àñòè

      LastKnownGood->Size = tail - sizeof(MemBlock);

      address = ( (Byte *)BlockForCheck ) + sizeof(MemBlock);

	  // îòïóñòèì ìüþòåêñ

      rtlInterlockedExchange( &mmMutex, FALSE );

      return address;

    }

    else

    {

      //ïåðåìåñòè áëîê èç î÷åðåäè ñâîáîäíûõ â íà÷àëî î÷åðåäè çàíÿòûõ

      //ñíà÷àëà âûêèíåì åãî èç î÷åðåäè ñâîáîäíûõ

      if ( LastKnownGood->Previous != NULL )

      {

        LastKnownGood->Previous->Next = LastKnownGood->Next;

      }

      else

      {

        //áëîê ñòîèò â íà÷àëå î÷åðåäè

        rootfree = LastKnownGood->Next;

      }

      if( LastKnownGood->Next != NULL )

      {

        LastKnownGood->Next->Previous = LastKnownGood->Previous;

      }

      //òåïåðü âñòàâèì åãî â î÷åðåäü çàíÿòûõ

      if( rootuser != NULL )

      {

        LastKnownGood->Next = rootuser;

        rootuser->Previous = LastKnownGood;

        LastKnownGood->Previous = NULL;

        rootuser = LastKnownGood;

      }

      else

      {

        rootuser = LastKnownGood;

        LastKnownGood->Next = NULL;

        LastKnownGood->Previous = NULL;

      }

	  //

      address = ( (Byte *)LastKnownGood ) + sizeof(MemBlock);

	  // îòïóñòèì ìüþòåêñ

      rtlInterlockedExchange( &mmMutex, FALSE );

      return address;

    }

  }

  else

  {

    //íàäî ïîëó÷èòü åù¸ êóñî÷åê ïàìÿòè

    LastKnownGood = (MemBlock *)AllocMemFromSystem( reqsize + sizeof(MemBlock) );

	//

    if( LastKnownGood != NULL )

    {

      LastKnownGood->Size = reqsize;

      //òåïåðü âñòàâèì åãî â î÷åðåäü çàíÿòûõ

      if( rootuser != NULL )

      {

        LastKnownGood->Next = rootuser;

        rootuser->Previous = LastKnownGood;

        LastKnownGood->Previous = NULL;

        rootuser = LastKnownGood;

      }

      else

      {

        rootuser = LastKnownGood;

        LastKnownGood->Next = NULL;

        LastKnownGood->Previous = NULL;

      }

      address = ( (Byte *)LastKnownGood ) + sizeof(MemBlock);

	  // îòïóñòèì ìüþòåêñ

      rtlInterlockedExchange( &mmMutex, FALSE );

      return address;

    }

  }

  // îòïóñòèì ìüþòåêñ

  rtlInterlockedExchange( &mmMutex, FALSE );

  //

  rtlDebugOutString( "allocmem failed." );

  kos_ExitApp();

  //

  return NULL;

}

//

Dword freemem( void *vaddress )

{

  Dword result;

  Byte *checknext, *address = (Byte *)vaddress;

  // æä¸ì îñâîáîæäåíèÿ ìüþòåêñà

  while ( rtlInterlockedExchange( &mmMutex, TRUE ) )

  {

	  //

	  kos_Pause( 1 );

  }

  MemBlock *released = (MemBlock *)( address - sizeof(MemBlock) );

  result = released->Size;

  //óáèðàåì áëîê èç ñïèñêà çàíÿòûõ

  if ( released->Previous != NULL )

  {

    released->Previous->Next = released->Next;

  }

  else

  {

    rootuser = released->Next;

  }

  if ( released->Next != NULL )

  {

    released->Next->Previous = released->Previous;

  }

  //çàêèíåì òåïåðü ýòîò áëîê â ñïèñîê ñâîáîäíûõ

  released->Next = rootfree;

  released->Previous = NULL;

  rootfree = released;

  if ( released->Next != NULL )

  {

    released->Next->Previous = released;

  }

  //òåïåðü ïîèùåì ñìåæíûå ñâîáîäíûå áëîêè

  checknext = (Byte *)(rootfree) + ( rootfree->Size + sizeof(MemBlock) );

  //

  for ( released = rootfree->Next; released != NULL; released = released->Next )

  {

    if ( checknext == (Byte *)released )

    {

      //ñîáèðàåì áëîêè âìåñòå

      //ñíà÷àëà âûêèíåì èç î÷åðåäè ñâîáîäíûõ

      released->Previous->Next = released->Next;

      if( released->Next != NULL )

      {

        released->Next->Previous = released->Previous;

      }

      //òåïåðü óâåëè÷èì ðàçìåð êîðíåâîãî áëîêà

      rootfree->Size += released->Size + sizeof(MemBlock);

      break;

    }

  }

  //åñëè íàäî, ïîèùåì áëîêè ïåðåä òåêùèì.

  checknext = (Byte *)(rootfree);

  //

  if ( released == NULL )

  {

    for ( released = rootfree->Next; released != NULL; released = released->Next )

    {

      if ( checknext == (Byte *)released + ( released->Size + sizeof(MemBlock) ) )

      {

        //ñîáèðàåì áëîêè âìåñòå

        //óâåëè÷èì ðàçìåð áëîêà

        released->Size += rootfree->Size + sizeof(MemBlock);

        //òåïåðü âûêèíåì èç î÷åðåäè ñâîáîäíûõ

        released->Previous->Next = released->Next;

        if ( released->Next != NULL )

        {

          released->Next->Previous = released->Previous;

        }

        //è çàêèíåì åãî â íà÷àëî î÷åðåäè âìåñòî ïðèñîåäèí¸ííîãî áëîêà èç êîðíÿ ñïèñêà

        if ( rootfree->Next != NULL )

        {

          rootfree->Next->Previous = released;

        }

        released->Next = rootfree->Next;

        released->Previous = NULL;

        rootfree = released;

        break;

      }

    }

  }

  // îòïóñòèì ìüþòåêñ

  rtlInterlockedExchange( &mmMutex, FALSE );

  return result;

}

*/