Changeset 277

Timestamp:

Dec 10, 2002, 3:11:54 PM (18 years ago)

Author:

pooh

Message:

• Added get_block() methods.

Location:

to-imperative/trunk/libp++

Files:

• pxx_allocator.hh (modified) (1 diff)
• pxx_default_allocator.hh (modified) (1 diff)
• pxx_default_allocator.ih (modified) (1 diff)
• pxx_heap_allocator.hh (modified) (1 diff)
• pxx_heap_allocator.ih (modified) (1 diff)
• pxx_malloc_allocator.hh (modified) (1 diff)
• pxx_malloc_allocator.ih (modified) (1 diff)

to-imperative/trunk/libp++/pxx_allocator.hh

@@ -60 +60 @@
   // of memory block to be allocated
   virtual size_t get_real_size (size_t _size) = 0 ;
+  //
+  // Returns (if possible) the start address of allocated block containing a
+  // pointer, otherwise returns null
+  virtual void* get_block (void* _ptr) = 0 ;
+  //
+  // The same as previous, but using block size
+  virtual void* get_block (void* _ptr, size_t _size) = 0 ;
 
 };

to-imperative/trunk/libp++/pxx_default_allocator.hh

@@ -74 +74 @@
   // of memory block to be allocated
   inline size_t get_real_size (size_t _size) ;
+  //
+  // Returns (if possible) the start address of allocated block containing a
+  // pointer, otherwise returns null
+  inline void* get_block (void* _ptr) ;
+  //
+  // The same as previous, but using block size
+  inline void* get_block (void* _ptr, size_t _size) ;
 
 };

to-imperative/trunk/libp++/pxx_default_allocator.ih

@@ -66 +66 @@
 }
 
+//
+// Returns (if possible) the start address of allocated block containing a
+// pointer, otherwise returns null
+inline void* DefaultAllocator::get_block (void* _ptr)
+{
+  if (allocator == null) set(default_malloc_allocator);
+  return allocator->get_block(_ptr);
+}
+
+//
+// The same as previous, but using block size
+inline void* DefaultAllocator::get_block (void* _ptr, size_t _size)
+{
+  if (allocator == null) set(default_malloc_allocator);
+  return allocator->get_block(_ptr, _size);
+}
+
 inline Allocator& DefaultAllocator::get ()
 {

to-imperative/trunk/libp++/pxx_heap_allocator.hh

@@ -129 +129 @@
   inline size_t get_size (void* _ptr) ;
   //
+  // Returns (if possible) the start address of allocated block containing a
+  // pointer, otherwise returns null
+  inline void* get_block (void* _ptr) ;
+  //
+  // The same as previous, but using block size
+  inline void* get_block (void* _ptr, size_t _size) ;
+  //
   // Dump memory map
   void memory_dump () ;

to-imperative/trunk/libp++/pxx_heap_allocator.ih

@@ -95 +95 @@
 }
 
+//
+// Returns (if possible) the start address of allocated block containing a
+// pointer, otherwise returns null
+inline void* HeapAllocator::get_block (void* _ptr)
+{
+  size_t s = current_size;
+  while (s >= min_free_size) {
+    void* p =
+      ptr_add_offset(start_addr, ptr_sub(_ptr, start_addr) & (~(s - 1)));
+    if (((BlockHeader*)p)->size == (s | 0x01))
+      return ptr_add_offset(p, sizeof(uintptr_t));
+    s >>= 1;
+  }
+  return null;
+}
+
+//
+// The same as previous, but using block size
+inline void* HeapAllocator::get_block (void* _ptr, size_t _size)
+{
+  _size += sizeof(uintptr_t);
+  if (_size < min_free_size) _size = min_free_size ;
+  _size = exps_of_two[get_order(_size)];
+  void* real_block =
+    ptr_add_offset(start_addr, ptr_sub(_ptr, start_addr) & (~(_size - 1)));
+  return ptr_add_offset(real_block, sizeof(uintptr_t));
+}
+
 }
 

to-imperative/trunk/libp++/pxx_malloc_allocator.hh

@@ -59 +59 @@
   // of memory block to be allocated
   inline size_t get_real_size (size_t _size) ;
+  //
+  // Returns (if possible) the start address of allocated block containing a
+  // pointer, otherwise returns null
+  inline void* get_block (void* _ptr) ;
+  //
+  // The same as previous, but using block size
+  inline void* get_block (void* _ptr, size_t _size) ;
 };
 

to-imperative/trunk/libp++/pxx_malloc_allocator.ih

@@ -71 +71 @@
 }
 
+//
+// Returns (if possible) the start address of allocated block containing a
+// pointer, otherwise returns null
+inline void* MallocAllocator::get_block (void*)
+{
+  return null;
+}
+
+//
+// The same as previous, but using block size
+inline void* MallocAllocator::get_block (void*, size_t)
+{
+  return null;
+}
+
 }