[내장형]김정우-11월30일

BrickOS
메모리 관리

make : 반자동 컴파일.
make clean : 코드작성시 수정가능한 파일들을 지운다. 수정할 필요없는 실행파일들은 남겨 놓는다.
make realclean : make관련 모든 파일을 다 지운다.....
(make realclean 했다가 폴더를 여러번 복사함....ㅠㅠ )

 

먼저....brickOS에서는 메모리를 커널과 유저의 두가지로 구분돼 있고 커널 코드와 커널의 스태틱  데이터는 0X8000번지에서 시작해 mm_start까지 위치 한다. 여기까지는 글로벌 변수라고 봐야 한다. mm_start부터 0xFFFF가지가 우리가 활용할 메모리 영역이다.

         <기본 메모리 블럭>
 우리가 사용하는 일반적인 운영체제에서의 메모리는 4바이트 단위로 블럭을 계산하고 int형도 4바이트 지만 여기서 사용할 메모리는 2바이트 word단위로 사용하면서 int가 2바이트 라는 것을 기억해야 한다.
위의 기본 메모리 블럭을 생각하며 다음내용을 보면 조금은 이해하기가 쉬울듯...


brickos.lds 에서 mm_start의 주소를 알아보면... 0x2E6A 라고 나와있다.

커널이 기동되는 동안, mm_init()함수에서 메모리를 초기화 한다.

// mm_init에서 메모리 초기화 할대 free시키는 메크로 함수
#define MM_BLOCK_FREE(addr)           \
  next=(size_t*)(addr);          \
  *current=((((size_t)next)-(size_t)current)-2)>>1;  \
  *(next++)=MM_FREE;          \
  current=next;

// free 시키지 않을 메모리영역  설정하는 메크로 함수
#define MM_BLOCK_RESERVED(addr)         \
  next=(size_t*)(((size_t)addr)-4);      \
  *current=((((size_t)next)-(size_t)current)-2)>>1;  \
  *(next++)=MM_RESERVED;          \
  current=next;

void mm_init() {
   size_t *current,*next;
   
   current=&mm_start;
 
   // memory layout
   //
   MM_BLOCK_FREE    (&mm_start);   // ram
   
                                   // something at 0xc000 ?
   
   MM_BLOCK_RESERVED(0xef30);      // lcddata
   MM_BLOCK_FREE    (0xef50);      // ram2
   MM_BLOCK_RESERVED(0xf000);      // motor
   MM_BLOCK_FREE    (0xfe00);      // ram4
   MM_BLOCK_RESERVED(0xff00);      // stack, onchip
 
   // expand last block to encompass all available memory
   *current=(int)(((-(int) current)-2)>>1);
   
   mm_update_first_free(&mm_start);
// mm_start가 최초의 프리블럭이 된다.
 }

 

mm_start_free가  최초의 프리 블럭을 가리키도록 설정 된다.소스에서 보면 mm_update_first_free(&mm_start);
에서 수행한다.
 초기화 과정은 MM_BLOCK_FREE(addr)과 MM_BLOCK_RESERVED(addr)이라는 2개의 매크로를 통해 이루어 진다.

초기화를 했으면 이제 malloc의 호출시 어떻게 코드가 되어 있는지 알아보자.
malloc명령을 하면 함수가 호출이 될것이다. 함수를 살펴 보면...

void *malloc(size_t size) {
  size_t *ptr,*next;
  
  size=(size+1)>>1;       // only multiples of 2
  /* size를 받아서 1을 더하고 쉬프트 연산을 한다. 왜 이럴까??
   먼저 >>1하는 이유는 2바이트 단위의 블럭이기 때문이다. 그럼 1은 왜 더할까?
   홀수크기가 들어올때 2로 나누면 들어온 크기보다 메모리 블럭이 적게 할당되기 때문에 1을 더해서 나누면 그런 현상이 없어진다.*/

#ifdef CONF_TM   // 테스크 메니져( 멀티시 사용한다.)
  ENTER_KERNEL_CRITICAL_SECTION();
#endif
  ptr=mm_first_free;    // 가장 처음 free영역
  
  while(ptr>=&mm_start) {   /* 메모리 끝가지 비교 0xFFFF를 하지 않은 이유는 메모리 특성상 끝이 없고 끝은 처음이기 때문에 FFFF를 넘어갈 시 반복적으로 돌기에 오버플로우가 발생해 무한 반복에 걸릴 수 있기때문에...*/
    if(*(ptr++)==MM_FREE) {     // free block?
#ifdef CONF_TM
      mm_try_join(ptr);   // unite with later blocks
#endif
      if(*ptr>=size) {    // big enough?
        *(ptr-1)=(size_t)ctid;  // set owner
              
              // split this block?
        if((*ptr-size)>=MM_SPLIT_THRESH) {
      // *ptr-size 는 남은 블럭수 , MM_SPLIT_THRESH 는 MM_HEADER_SIZE(2) +8
          next=ptr+size+1;  // 점프
          *(next++)=MM_FREE; // free영역 확보
          *(next)=*ptr-size-MM_HEADER_SIZE;  // 원하는 크기 입력
          mm_try_join(next);
          
          *ptr=size; // ptr에 크기를 기억한다.
        }
          
              // was it the first free one?
        if(ptr==mm_first_free+1)
          mm_update_first_free(ptr+*ptr+1);
        
#ifdef CONF_TM
        LEAVE_KERNEL_CRITICAL_SECTION();
#endif    
        return (void*) (ptr+1); 
      }
    }   
      
    ptr+=(*ptr)+1;        // find next block.
   // 블럭개수 +1 만큼 이동 할당받을 블럭이 없어서 다음 블럭으로 넘어간다.
  }
  
#ifdef CONF_TM
  LEAVE_KERNEL_CRITICAL_SECTION();
#endif    
  return NULL;
}

메모리에서 어찌어찌 하여 할당을 받았다. 이제 해제를 하는 것을 보자.
해제를 하기위해서는 얼마의 크기를 가지고 있는지를 알아야 한다. 위에서 할당 받을때 저장해놓은 크기를 확인하고 그만큼 반환을 하면 된다.

void free(void *the_ptr) {
    size_t *ptr=the_ptr; // 할당받았던 메모리에서 시작한다.
#ifndef CONF_TM
        size_t *p2,*next;
#endif  
  
  if(ptr==NULL || (((size_t)ptr)&1) ) // 인자 검사를 통해 짝수 블럭인지 확인을 한다.
    return;
  
  ptr-=MM_HEADER_SIZE; // tid를 확인하기 위해 위치 이동
  *((size_t*) ptr)=MM_FREE;     // mark as free
  // malloc에서 호출 가능하게 free시킨다.
#ifdef CONF_TM
  if(ptr<mm_first_free || mm_first_free<&mm_start)
    mm_first_free=ptr;      // update mm_first_free
   // 조건에 해당하면 처음 시작 영역을 이동시킨다.
#else
        // without task management, we have the time to
        // unite neighboring memory blocks.
        //
  p2=&mm_start;
  while(p2!=ptr) {        // we could make free
    next=p2+*(p2+1)+MM_HEADER_SIZE;   // O(1) if we included
    if(*p2==MM_FREE && next==ptr)   // a pointer to the 
      break;        // previous block.
    p2=next;        // I don't want to.
  }
  mm_try_join(p2+1);        // defragment free areas

  if(ptr<mm_first_free || mm_first_free<&mm_start)
    mm_update_first_free(ptr);    // update mm_first_free
#endif
}

 

calloc 은 동적할당을 해주면서 메모리를 초기화 시켜주는 함수이다. 하지만 자신이 직접 하는것이 아니라 malloc과 memset을 가져다 쓰면서 마치 자신이 한것같이 행동하는 함수이다. 
 

void *calloc(size_t nmemb, size_t size) {
  void *ptr;
  size_t original_size = size;

  if (nmemb == 0 || size == 0)
    return 0;
 
  size*=nmemb;

  // if an overflow occurred, size/nmemb will not equal original_size
  if (size/nmemb != original_size)
    return 0;
  
  if((ptr=malloc(size))!=NULL) // malloc을 호출해 일을 시킨다.
    memset(ptr,0,size);  // 초기화를 자신이 하지 않고 memset을 시킨다.

mm_free_mem 

int mm_free_mem(void) {
  int free = 0;
  size_t *ptr;
  
#ifdef CONF_TM
  ENTER_KERNEL_CRITICAL_SECTION();
#endif

  // Iterate through the free list
  for (ptr = mm_first_free; 
       ptr >= &mm_start; 
       ptr += *(ptr+1) + MM_HEADER_SIZE) // 메모리 전 영역에돌면서 확인
    free += *(ptr+1);

#ifdef CONF_TM
  LEAVE_KERNEL_CRITICAL_SECTION();
#endif    
  return free*2; // 블럭단위로 계산했던것을 2를 곱해 바이트로 반환한다.
}

mm_defalg 함수는 블럭들을 서로 연결시켜 주는 함수이고
mm_reaper 함수는 메모리를 free시키는 함수이다. 이 함수는 어떠한 특정 tid에 사용되었던 블럭들을 모두 free시킨다. 또 mm_defalg함수를 내부에서 호출하기 때문에 free된 메모리들을서로 모으는 기능가지 한다.