os_mem.lst

基于51单片机来实现UCOS用一个串口来看到实现阶段

C51 COMPILER V7.50   OS_MEM                                                                10/31/2005 15:29:42 PAGE 1   


C51 COMPILER V7.50, COMPILATION OF MODULE OS_MEM
OBJECT MODULE PLACED IN OS_MEM.OBJ
COMPILER INVOKED BY: C:\Program Files\keilc51\C51\BIN\C51.EXE OS_MEM.C LARGE BROWSE DEBUG OBJECTEXTEND

line level    source

   1          /*
   2          *********************************************************************************************************
   3          *                                                uC/OS-II
   4          *                                          The Real-Time Kernel
   5          *                                            MEMORY MANAGEMENT
   6          *
   7          *                        (c) Copyright 1992-1998, Jean J. Labrosse, Plantation, FL
   8          *                                           All Rights Reserved
   9          *
  10          *                                                  V2.00
  11          *
  12          * File : OS_MEM.C
  13          * By   : Jean J. Labrosse
  14          *********************************************************************************************************
  15          */
  16          
  17          #ifndef  OS_MASTER_FILE
  18          #include "includes.h"
  19          #endif
  20          
  21          #if OS_MEM_EN && OS_MAX_MEM_PART >= 2
              /*
              *********************************************************************************************************
              *                                         LOCAL GLOBAL VARIABLES
              *********************************************************************************************************
              */
              
              static  OS_MEM      *OSMemFreeList;            /* Pointer to free list of memory partitions            */
              static  OS_MEM       OSMemTbl[OS_MAX_MEM_PART];/* Storage for memory partition manager                 */
              
              //建立一个内寸分区
              OS_MEM *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *err)reentrant
              {
                  OS_MEM  *pmem;
                  INT8U   *pblk;
                  void   **plink;
                  INT32U   i;
              
              
                  if (nblks < 2) {                                  /* Must have at least 2 blocks per partition      */
                      *err = OS_MEM_INVALID_BLKS;
                      return ((OS_MEM *)0);
                  }
                  if (blksize < sizeof(void *)) {                   /* Must contain space for at least a pointer      */
                      *err = OS_MEM_INVALID_SIZE;
                      return ((OS_MEM *)0);
                  }
                  OS_ENTER_CRITICAL();
                  pmem = OSMemFreeList;                             /* Get next free memory partition                */
                  if (OSMemFreeList != (OS_MEM *)0) {               /* See if pool of free partitions was empty      */
                      OSMemFreeList = (OS_MEM *)OSMemFreeList->OSMemFreeList;
                  }
                  OS_EXIT_CRITICAL();
                  if (pmem == (OS_MEM *)0) {                        /* See if we have a memory partition             */
                      *err = OS_MEM_INVALID_PART;
C51 COMPILER V7.50   OS_MEM                                                                10/31/2005 15:29:42 PAGE 2   

                      return ((OS_MEM *)0);
                  }
                  plink = (void **)addr;                            /* Create linked list of free memory blocks      */
                  pblk  = (INT8U *)addr + blksize;
                  for (i = 0; i < (nblks - 1); i++) {
                      *plink = (void *)pblk;
                      plink  = (void **)pblk;
                      pblk   = pblk + blksize;
                  }
                  *plink = (void *)0;                               /* Last memory block points to NULL              */
                  OS_ENTER_CRITICAL();
                  pmem->OSMemAddr     = addr;                       /* Store start address of memory partition       */
                  pmem->OSMemFreeList = addr;                       /* Initialize pointer to pool of free blocks     */
                  pmem->OSMemNFree    = nblks;                      /* Store number of free blocks in MCB            */
                  pmem->OSMemNBlks    = nblks;
                  pmem->OSMemBlkSize  = blksize;                    /* Store block size of each memory blocks        */
                  OS_EXIT_CRITICAL();
                  *err   = OS_NO_ERR;
                  return (pmem);
              }
              
              //分配一个内存块
              void *OSMemGet (OS_MEM *pmem, INT8U *err)reentrant
              {
                  void    *pblk;
              
              
                  OS_ENTER_CRITICAL();
                  if (pmem->OSMemNFree > 0) {                       /* See if there are any free memory blocks       */
                      pblk                = pmem->OSMemFreeList;    /* Yes, point to next free memory block          */
                      pmem->OSMemFreeList = *(void **)pblk;         /*      Adjust pointer to new free list          */
                      pmem->OSMemNFree--;                           /*      One less memory block in this partition  */
                      OS_EXIT_CRITICAL();
                      *err = OS_NO_ERR;                             /*      No error                                 */
                      return (pblk);                                /*      Return memory block to caller            */
                  } else {
                      OS_EXIT_CRITICAL();
                      *err = OS_MEM_NO_FREE_BLKS;                   /* No,  Notify caller of empty memory partition  */
                      return ((void *)0);                           /*      Return NULL pointer to caller            */
                  }
              }
              
              //内存块初始化
              void OSMemInit (void)reentrant
              {
                  OS_MEM  *pmem;
                  INT16U   i;
              
              
                  pmem = (OS_MEM *)&OSMemTbl[0];                    /* Point to memory control block (MCB)           */
                  for (i = 0; i < (OS_MAX_MEM_PART - 1); i++) {     /* Init. list of free memory partitions          */
                      pmem->OSMemFreeList = (void *)&OSMemTbl[i+1]; /* Chain list of free partitions                 */
                      pmem->OSMemAddr     = (void *)0;              /* Store start address of memory partition       */
                      pmem->OSMemNFree    = 0;                      /* No free blocks                                */
                      pmem->OSMemNBlks    = 0;                      /* No blocks                                     */
                      pmem->OSMemBlkSize  = 0;                      /* Zero size                                     */
                      pmem++;
                  }
                  OSMemTbl[OS_MAX_MEM_PART - 1].OSMemFreeList = (void *)0;
                  OSMemFreeList                               = (OS_MEM *)&OSMemTbl[0];
              }
              
C51 COMPILER V7.50   OS_MEM                                                                10/31/2005 15:29:42 PAGE 3   

              //释放一个内存块
              INT8U OSMemPut (OS_MEM  *pmem, void *pblk)reentrant
              {
                  OS_ENTER_CRITICAL();
                  if (pmem->OSMemNFree >= pmem->OSMemNBlks) {  /* Make sure all blocks not already returned          */
                      OS_EXIT_CRITICAL();
                      return (OS_MEM_FULL);       
                  }
                  *(void **)pblk      = pmem->OSMemFreeList;   /* Insert released block into free block list         */
                  pmem->OSMemFreeList = pblk;
                  pmem->OSMemNFree++;                          /* One more memory block in this partition            */
                  OS_EXIT_CRITICAL();
                  return (OS_NO_ERR);                          /* Notify caller that memory block was released       */
              }
              
              //查询一个内存分区章状态
              INT8U OSMemQuery (OS_MEM *pmem, OS_MEM_DATA *dataptr)reentrant
              {
                  OS_ENTER_CRITICAL();
                  dataptr->OSAddr     = pmem->OSMemAddr;
                  dataptr->OSFreeList = pmem->OSMemFreeList;
                  dataptr->OSBlkSize  = pmem->OSMemBlkSize;
                  dataptr->OSNBlks    = pmem->OSMemNBlks;
                  dataptr->OSNFree    = pmem->OSMemNFree;
                  OS_EXIT_CRITICAL();
                  dataptr->OSNUsed    = dataptr->OSNBlks - dataptr->OSNFree;
                  return (OS_NO_ERR);                         
              }
              #endif


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   ----    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


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