pooled_allocator.cc

简单的动态内存管理程序源代码

  ////////////////////////////////////////////////////////////////////
  //////                          Chunk::mark()
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        global_start_element - first element of found block
  //////        num_of_elements      - memory for num_of_elements
  //////        
  //////        mark as used in the bit vector
  //////        
  ////////////////////////////////////////////////////////////////////

  void Chunk::mark(int global_start_element,int num_of_elems) {
    // mark num_of_elems starting at start_element
    // as assigned.  This function is used to link
    // newly freed memory with a previous free block.
    if ((first_elem_num <= global_start_element)&&
	(global_start_element <  (first_elem_num+num_of_elements)) ) {
      int local_start_element=global_start_element-first_elem_num;
      bit_vec.mark_items(local_start_element,num_of_elems);
    } else {
      std::clog << __FILE__ << ':' << __LINE__ << ':' << " mark(): ";
      std::clog << "requested start_element outside of chunk.\n";
      std::clog << "first_elem_num: " << first_elem_num << std::endl;
    }
    return;
  };  // Chunk::mark()

  ////////////////////////////////////////////////////////////////////
  //////                          Chunk::clear() 
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        start_element - first element of found block
  //////        num_of_elems - memory for num_of_elements
  //////        
  //////        clear set blocks as unused in the bit vector
  //////        
  ////////////////////////////////////////////////////////////////////

  void Chunk::clear(int global_start_element,int num_of_elems) {
    // clear num_of_elems starting at start_element
    // as available.
    if ((first_elem_num<=global_start_element)&&
	(global_start_element<(first_elem_num+num_of_elements))) {
      int local_start_element=global_start_element-first_elem_num;
      bit_vec.clear_items(local_start_element,num_of_elems);
    } else {
      std::clog << __FILE__ << ':' << __LINE__ << ':' << " clear(): ";
      std::clog << "requested start_element outside of chunk.\n";
      std::clog << " first_elem_num: " << first_elem_num <<
	"  num_of_elements: " << num_of_elements << std::endl;
    }
    return;
  };  // Chunk::clear()

  ////////////////////////////////////////////////////////////////////
  //////     Chunk::element_num_to_pointer(int global_start_element)
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        global_start_element -  compute the memory  address of
  //////                                this global element number.
  //////        
  //////        find and return the memory address, p, for this global
  //////        element number.  Used to free blocks which are in use.
  //////        
  ////////////////////////////////////////////////////////////////////


  unsigned char*
  Chunk::element_num_to_pointer(int global_start_element) {
    // Calculate and  return the  global block(element) number  of the
    // block residing at p.
    int local_start_element = global_start_element - first_elem_num;
    unsigned char* p = 0;
    if ((0 <= local_start_element) &&
	(local_start_element < num_of_elements)) {
      p = mem+(local_start_element*element_size);
    } else {
      std::clog << __FILE__ << ':' << __LINE__ << ':' << " element_num_to_pointer(): ";
      std::clog << "requested block outside of chunk.\n";
    }
    return p;
  }; // Chunk::element_num_to_pointer()

  ////////////////////////////////////////////////////////////////////
  //////                  Chunk::get_page_offset()
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        Calculate the  offset from the beginning  of the Chunk
  //////        to the specified page number.
  //////        
  ////////////////////////////////////////////////////////////////////


  const int Chunk::get_element_offset(int global_start_element) {
    int element_num = global_start_element - first_elem_num;
    if (element_num < 0) {
	  std::clog << "Error: " << __FILE__ << ':' << __LINE__ ;
	  std::clog << ": element number out of range: " 
		    << element_num << std::endl;
	  throw (Alloc_Exception::alloc_exception(0));
    }
    return (sizeof(Chunk) +	// chunk header
	    bit_vec_size +	// bit_vec space
	    element_num*element_size); // count to element
  };  // const int Chunk::get_page_offset(int page_num)

  ////////////////////////////////////////////////////////////////////
  //////                   Chunk::find_element_num()
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        p  -  pointer to  allocated  memory.  
  //////        
  //////        Returns element number corresponding to p if p is from
  //////        this chunk,  or -1  if p is  not from the  chunk.  The
  //////        element number  returned is the  local element number,
  //////        not the global element number.
  //////        
  ////////////////////////////////////////////////////////////////////

  int Chunk::pointer_to_element_num(const unsigned char* p) {
    int element_num = -1;
    // set chunk memory lower bound
    const unsigned char* lower_bound = mem;
    // set chunk memory upper bound
    const unsigned char* upper_bound = lower_bound +
      element_size*num_of_elements;
    if ((lower_bound<=p)&&(p<upper_bound)) {
      // if the pointer is in the memory range of this chunk
      element_num =
	(static_cast<int>(p-lower_bound))/element_size;
    }  // if ((lower_bound<=p)&&(p<upper_bound))
    return element_num;
  };

  ////////////////////////////////////////////////////////////////////
  //////                           Chunk::allocate()
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        global_start_element - first element of found block
  //////        num_of_elements - memory for num_of_elements
  //////        
  //////        allocate  adjusts  pointers in  the  memory chunk  and
  //////        returns  a  pointer  to  the start  of  the  allocated
  //////        memory.
  //////        
  ////////////////////////////////////////////////////////////////////

  mem_space::memory_index_t
  Chunk::allocate(int global_start_element,
		  int num_of_elems) {
    // allocate num_of_elems starting with element start_element
    // assumes that:
    //    1. global_start_element has  already been located  by find()
    //       as a free block,
    //    2. That the  memory at global_start_element  has been marked
    //       as allocated by mark() and is now ready to be returned

    // mark the elements as in use.
    mark(global_start_element,num_of_elems);
    unsigned char* p = element_num_to_pointer(global_start_element);
    // The  segment_page_num can  be used  to determine  global offset
    // from beginning  of a  memory segment to  the start of  a shared
    // memory segment page.  Chunks  are allocated so that they reside
    // a  the  beginnings  of   these  pages.   The  global  offset  =
    // chunk_offset +  element_offset within the  chunk.  These values
    // are used to compute the  offset from segment start to beginning
    // of this chunk, to a specific element if desired.
//     int segment_page_num = get_segment_page_num();
    // compute offset from beginning of this chunk to element number.
    int element_offset = get_element_offset(global_start_element);
    // return p;

    return mem_space::memory_index_t(p,
				     pathname,
 				     proj_id,
				     segment_page_num,
				     element_offset,
				     global_start_element);
  };  // Chunk::allocate()

  ////////////////////////////////////////////////////////////////////
  //////                           Chunk::free()
  ////////////////////////////////////////////////////////////////////
  //////        
  //////        num_of_elems - memory for num_of_elems
  //////        
  //////        free adjusts pointers in the memory chunk 
  //////        
  //////        
  ////////////////////////////////////////////////////////////////////

  // release chunk elements
  void Chunk::free(int global_start_element, int num_of_elems) {
    clear(global_start_element,num_of_elems);
    return;
    
  };  // Chunk::free()

  

}  // namespace pooled_allocator