kmm.lst

realtime RTOS NEW

C51 COMPILER V6.12  KMM                                                                    12/07/2004 17:58:48 PAGE 1   


C51 COMPILER V6.12, COMPILATION OF MODULE KMM
OBJECT MODULE PLACED IN .\kmm.obj
COMPILER INVOKED BY: C:\Keil\C51\BIN\C51.EXE ..\..\..\memory\kmm.c INCDIR(d:\rs1.12b\) DEBUG OBJECTEXTEND PRINT(.\kmm.ls
                    -t) OBJECT(.\kmm.obj) 

stmt level    source

   1          /*
   2          ===============================================================================
   3          | Copyright (C) 2004 RuanHaiShen, All rights reserved.
   4          | SUMMARY: 
   5          |   Memory management implementation.
   6          |
   7          | DESCRIPTION:
   8          |   See http://www.01s.org for documentation, latest information, license 
   9          |   and contact details.
  10          |   email:[e-mail]
  11          =============================================================================*/
  12          /*===========================================================================*/
  13          #include "arch/arch.h"
  14          #include "inc/queue.h"
  15          #include "inc/kernel.h"
  16          #include "inc/memory.h"
  17          #include "inc/ipc.h"
  18          #include "inc/kapi.h"
  19          
  20          
  21          #if CFG_MM_EN > 0 
              
              #define PAGE_SIZE (sizeof(_mms)/sizeof(mm_t))
              #define MM_USED   ((u8)(((u32)MM_START) >> 24) - 1)
              
              #ifdef CFG_MM_START_ADDR
              # define MM_START   ((byte __p_*)(CFG_MM_START_ADDR)) /*memory start address*/
              #else
              # define MM_START   _heap                        /*memory start address*/
              static  byte        _heap[CFG_MM_SIZE];
              #endif
              
              static u8 _mm_used = 0xa5;
              static mm_t _mms[] = {CFG_MM_BLOCKS};
              
              
              #if CFG_DEBUG > 0
              static void __mm_flag_check(void)
              {
                  block_t bk;
              
              #if PTR_SIZE == 4
                  bk.u.next = (block_t __p_*)0x19831117L;
                  __ASSERT(bk.u.used.flags == 0x19);
              #elif PTR_SIZE == 3
                  bk.u.next = (block_t __p_*)0x198311L;
                  __ASSERT(bk.u.used.flags == 0x19);
              #elif PTR_SIZE == 2
                  bk.u.next = (block_t __p_*)0x1983;
                  __ASSERT(bk.u.used.flags == 0x19);
              #endif
              }
              #endif
              
C51 COMPILER V6.12  KMM                                                                    12/07/2004 17:58:48 PAGE 2   

              
              static void __mm_block_init(byte __p_* block_start, mmsz_t size, mmsz_t blocks)
              {
                  register u32 i;
                  register block_t __p_* bk;
              
                  bk = (block_t __p_*)block_start;
                  for (i = 0; i < blocks - 1; i++) {
                      bk->u.next = (block_t __p_*)((byte __p_*)bk + size);
                      bk = bk->u.next;
                  }
                  bk->u.next = NULL;
              }
              
              
              static uint __mm_get_page(mmsz_t size)
              {
                  register uint page;
              
                  /*add the size of the header */
                  size += sizeof(block_t);
                  for (page = 0; page < PAGE_SIZE; page++) {
                      if (size <= _mms[page].size) {
                          return page;
                      }
                  }
                  return PAGE_SIZE;
              }
              
              
              void __mm_init(void)
              {
                  register uint i;
                  register byte __p_* block_start;
              
              #if CFG_DEBUG > 0
                  __mm_flag_check();
              #endif
              
                  /*initialize memory used flag*/
                  _mm_used = MM_USED;
              
                  block_start = MM_START;
                  for (i = 0; i < PAGE_SIZE; i++) {
                      __mm_block_init(block_start, _mms[i].size, _mms[i].blocks);
                      _mms[i].firstfree = (block_t __p_*)block_start;
                      block_start += _mms[i].size * _mms[i].blocks;
                      _mms[i].nfrees = _mms[i].blocks;
                  }
              }
              
              void __p_* kmalloc(mmsz_t size)
              {
                  register uint page;
                  register block_t __p_* bk;
              
                  __ASSERT(size != 0);
              
                  page = __mm_get_page(size);
                  if (page == PAGE_SIZE) {
                      return NULL;
                  }
C51 COMPILER V6.12  KMM                                                                    12/07/2004 17:58:48 PAGE 3   

              
                  CRITICAL_ENTER;
                  if ((bk = _mms[page].firstfree) != NULL) {
                      _mms[page].firstfree = bk->u.next;
                      CRITICAL_EXIT;
                      bk->u.used.page  = (u8)(page);
                      bk->u.used.flags = _mm_used;
                      return bk + 1;   /*increments past header*/            
                  }
                  CRITICAL_EXIT;
              
                  return NULL;
              }
              
              void kfree(void __p_* ptr)
              {
                  register uint page;
                  register block_t __p_* bk;
              
                  __ASSERT(ptr != NULL);
              
                  bk = (block_t __p_*)ptr - 1;
                  CRITICAL_ENTER;
                  if (bk->u.used.flags == _mm_used) {
                      page = (uint)bk->u.used.page;
                      bk->u.next = _mms[page].firstfree;
                      _mms[page].firstfree = bk;
                  }
                  CRITICAL_EXIT;
              }
              
              err_t mm_status(void)
              {
                  uint i, k;
                  block_t __p_* bk;
              
                  for (i = 0; i < PAGE_SIZE; i++) {
                      task_lock();
                      bk = _mms[i].firstfree;
                      for (k = 0; bk != NULL; k++) {
                          bk = bk->u.next;
                      }
                      task_unlock();
                      _mms[i].nfrees = k;
                  }
                  return EOK;
              }
              #endif
 165          
 166          
 167          /*===========================================================================*/
 168          
 169          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   ----    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
C51 COMPILER V6.12  KMM                                                                    12/07/2004 17:58:48 PAGE 4   

   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)