Windows記憶體機制解析(二)原始碼 (轉)

Windows記憶體機制解析(二)原始碼 (轉)[@more@]

//myallocator.h

#ifndef _MYALLOCATOR_
#define _MYALLOCATOR_

#include
#include <.h>

namespace MyLib {
  template
  class MyAlloc {
  public:
  static HANDLE hHeap;
  // type definitions
  typedef T  value_type;
  typedef T*  pointer;
  typedef const T* const_pointer;
  typedef T&  reference;
  typedef const T& const_reference;
  typedef size_t  size_type;
  typedef ptrdiff_t difference_type;

  // rebind allocator to type U
  template
  struct rebind {
  typedef MyAlloc other;
  };

  // return address of values
  pointer address (reference value) const {
  return &value;
  }
  const_pointer address (const_reference value) const {
  return &value;
  }

  /* constructors and destructor
  * - nothing to do because the allocator has no state
  */
  MyAlloc() throw() {
  }
  MyAlloc(const MyAlloc&) throw() {
  }
  ~MyAlloc() throw() {
  }

  // return maximum number of elements that can be allocated
  size_type max_size () const throw() {
  size_type N;
  N=(size_type)(-1)/ sizeof(T);

  return  (0 < N ? N : 1);
  }

  // allocate but don't initialize num elements of type T
  pointer allocate (size_type num, const void* = 0) {
  // print message and allocate memory with global new
  /*std::cerr << "allocate " << num << " element(s)"
  << " of size " << sizeof(T) << std::endl;
 */
  pointer ret = (pointer)(HeapAlloc(hHeap,0,num*sizeof(T)));
  // std::cerr << " allocated at: " << (void*)ret << std::endl;
  return ret;
  }
 char *_Charalloc(size_type N)//所附帶的stl的特色
 {
 return (char*)HeapAlloc(hHeap,0,N*sizeof(T));
 }
  // initialize elements of allocated storage p with value value
  void construct (pointer p, const T& value) {
  // initialize memory with placement new
  new((void*)p)T(value);
  }

  // destroy elements of initialized storage p
  void destroy (pointer p) {
  // destroy s by calling their destructor
  p->~T();
  }

  // deallocate storage p of deleted elements
  //原本應該為pointer
  void deallocate (void* p, size_type num) {
  // print message and deallocate memory with global delete
  /*
  std::cerr << "deallocate " << num << " element(s)"
  << " of size " << sizeof(T)
  << " at: " << (void*)p << std::endl;
 */
  HeapFree(hHeap,0,(void*)p);
  }
  };

  // return that all specializations of this allocator are interchangeable
  template
  bool operator== (const MyAlloc&,
  const MyAlloc&) throw() {
  return true;
  }
  template
  bool operator!= (const MyAlloc&,
  const MyAlloc&) throw() {
  return false;
  }
}//end namespace MyLib
#endif

 

//teststlmem.cpp

/*
 written by leezy_2000
 03-9-5 15:12
*/
#include "stdafx.h"

#pragma warning(disable:4786)

//#define _STLP_USE_MALLOC
#include "myallocator.h"
#include
#include
#include
#include
#include
#include

typedef unsigned long ULONG_PTR, *PULONG_PTR;

using namespace std;

/*
  本需要注意的幾點：

  1、在實現自己的分配器，這樣可以使stl容器的變化不影響我們要監測的堆

  2、容器只能用vector否則任何堆的任何變化將導致Heap32Next始終返回TRUE
  這應該是的

  3、分配失敗的時候應該丟擲std::bad_alloc記憶體，此處考慮不會出現低
  記憶體的情況，沒丟擲此異常。即認定自編寫分配器分配記憶體時不會失敗。
*/

//用於比較堆記憶體塊的仿
//以塊大小來判定兩個HEAPENTRY32的大小
class HenfoCompare
{
public:
 bool operator() (const HEAPENTRY32& he1,const HEAPENTRY32& he2) const
 {
 return (he1.dwBlockSize < he2.dwBlockSize);
 }
};

typedef vector < HEAPENTRY32, MyLib::MyAlloc > HEAPENTRYSET;

void heapinfo(HEAPENTRYSET& hset,ULONG_PTR heapid);

void getheapid(set& heapid)
{
 HANDLE hSnapShot=CreateToolhelp32Snapshot(TH32CS_SNAPHEAPLIST,GetCurrentProcessId());
 HEAPLIST32  heaplist32;

 heaplist32.dwSize=sizeof(HEAPLIST32);

 BOOL bRet=Heap32ListFirst(hSnapShot,&heaplist32);

 while(bRet)
 {
 heapid.insert(heaplist32.th32HeapID);

 cout<

 bRet=Heap32ListNext(hSnapShot,&heaplist32);
 }
 CloseHandle(hSnapShot);

 cout<}

HANDLE MyLib::MyAlloc::hHeap=NULL;

HANDLE hHeap;

int main(int argc, char* argv[])
{
 //列舉此時所有堆並在建立新堆後再次列舉這樣從中剔除新建堆
 set heapid1,heapid2,heapid3;
 
 getheapid(heapid1);

 hHeap=HeapCreate(0,0,0);

 getheapid(heapid2);

 insert_iterator > iter(heapid3,heapid3.begin());

 set_difference(heapid2.begin(),heapid2.end(),heapid1.begin(),heapid1.end(),
 iter);

 set::iterator pos;
 ULONG_PTR newheapid;

 for( pos=heapid3.begin(); p!=heapid3.end(); ++pos)
 {
 cout< newheapid=*pos;
 }

 MyLib::MyAlloc::hHeap=hHeap;

 //vector > v1;
 HEAPENTRYSET heapset1,heapset2,heapset3;
 
 heapset1.reserve(400);//保證vector不自動增長
 heapset2.reserve(400);
 heapset3.reserve(400);

 int size;

 heapinfo(heapset1,newheapid);
 
 sort(heapset1.begin(),heapset1.end(),HeapInfoCompare());

 size=heapset1.size();

 HANDLE hCurHeap=GetProcessHeap();

// HeapAlloc(hCurHeap,HEAP_ZERO_MEMORY,4*1024);

 char* p=new char[4*1024];

// GlobalAlloc(GHND,4*1024);

 char* q=(char*)malloc(4*1024);

 cout<< "the p is"<

 heapinfo(heapset2,newheapid);

 sort(heapset2.begin(),heapset2.end(),HeapInfoCompare());
 size=heapset2.size();

 insert_iterator miter(heapset3,heapset3.begin());

 set_difference(heapset2.begin(),heapset2.end(),heapset1.begin(),heapset1.end(),
 miter,HeapInfoCompare());

 size=heapset3.size();

 HEAPENTRYSET::iterator mpos;
 for( mpos=heapset3.begin(); mpos !=heapset3.end(); ++mpos)
 {
 cout< cout< }

 return 0;
}
void heapinfo(HEAPENTRYSET& hset,ULONG_PTR hid)
{
 HANDLE hSnapShot=CreateToolhelp32Snapshot(TH32CS_SNAPHEAPLIST,GetCurrentProcessId());
 HEAPLIST32  heaplist32;

 heaplist32.dwSize=sizeof(HEAPLIST32);

 BOOL bRet=Heap32ListFirst(hSnapShot,&heaplist32);
 
 static int i=0;

 while(bRet)
 {
 HEAPENTRY32  he32;
 D totalsize=0,freesize=0;

 if(heaplist32.th32HeapID==hid)
 {
 bRet=Heap32ListNext(hSnapShot,&heaplist32);
 continue;
 }

 DWORD number=10;
 HANDLE ProcessHeap[10];

 DWORD numget=GetProcessHeaps(number,ProcessHeap);

 HANDLE hHeap=GetProcessHeap();

 he32.dwSize=sizeof(HEAPENTRY32);

 Heap32First(&he32,heaplist32.th32ProcessID,heaplist32.th32HeapID);

 if(he32.dwFlags & LF32_FREE)
 freesize +=he32.dwBlockSize;
 
 totalsize +=he32.dwBlockSize;

 cout<< "the heapid is :"< cout< 
 if((he32.dwFlags & LF32_FIXED) || (he32.dwFlags & LF32_MOVEABLE))
 hset.push_back(he32);

 while(Heap32Next(&he32))
 {
 cout<< "the information of block: " << "Blocksize: "<

 totalsize +=he32.dwBlockSize;

 if(he32.dwFlags & LF32_FREE)
 freesize +=he32.dwBlockSize;
 
 //cout<< ++i < if((he32.dwFlags & LF32_FIXED) || (he32.dwFlags & LF32_MOVEABLE))
 hset.push_back(he32);
 //char*p =(char*)malloc(300);

 }

 cout< cout< cout<

 bRet=Heap32ListNext(hSnapShot,&heaplist32);
 }

 CloseHandle(hSnapShot);

 cout<}