CSDN博客

img leezy_2000

Windows内存机制解析(二)源代码

发表于2003/10/9 22:21:00  2038人阅读

//myallocator.h

#ifndef _MYALLOCATOR_
#define _MYALLOCATOR_


#include <iostream>
#include <windows.h>


namespace MyLib {
   template <class T>
   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 <class U>
       struct rebind {
           typedef MyAlloc<U> 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)//vc 所附带的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 objects 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 <class T1, class T2>
   bool operator== (const MyAlloc<T1>&,
                    const MyAlloc<T2>&) throw() {
       return true;
   }
   template <class T1, class T2>
   bool operator!= (const MyAlloc<T1>&,
                    const MyAlloc<T2>&) 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 <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <windows.h>
#include <Tlhelp32.h>

typedef unsigned long ULONG_PTR, *PULONG_PTR;

using namespace std;

/*
  本程序需要注意的几点:

  1、在实现自己的分配器,这样可以使stl容器的变化不影响我们要监测的堆

  2、容器只能用vector否则任何堆的任何变化将导致Heap32Next始终返回TRUE
  这应该是微软的bug

  3、分配内存失败的时候应该抛出std::bad_alloc内存,此处考虑不会出现低
  内存的情况,没抛出此异常。即认定自编写分配器分配内存时不会失败。
*/

//用于比较堆内存块的仿函数
//以块大小来判定两个HEAPENTRY32的大小
class HeapInfoCompare
{
public:
 bool operator() (const HEAPENTRY32& he1,const HEAPENTRY32& he2) const
 {
  return (he1.dwBlockSize < he2.dwBlockSize);
 }
};

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

void heapinfo(HEAPENTRYSET& hset,ULONG_PTR heapid);

void getheapid(set<ULONG_PTR>& 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<<heaplist32.th32HeapID<<endl;

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

 cout<<"the end"<<endl;
}

HANDLE MyLib::MyAlloc<HEAPENTRY32>::hHeap=NULL;

HANDLE hHeap;

int main(int argc, char* argv[])
{
 //枚举此时所有堆并在建立新堆后再次枚举这样从中剔除新建堆
 set<ULONG_PTR> heapid1,heapid2,heapid3;
 
 getheapid(heapid1);

 hHeap=HeapCreate(0,0,0);

 getheapid(heapid2);

 insert_iterator<set<ULONG_PTR> > iter(heapid3,heapid3.begin());

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

 set<ULONG_PTR>::iterator pos;
 ULONG_PTR newheapid;

 for( pos=heapid3.begin(); pos !=heapid3.end(); ++pos)
 {
  cout<<"The new heap id is/t"<<(*pos)<<endl;
  newheapid=*pos;
 }


 MyLib::MyAlloc<HEAPENTRY32>::hHeap=hHeap;

 //vector<int, MyLib::MyAlloc<int> > 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"<<(int)p<<endl;

 heapinfo(heapset2,newheapid);

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

 insert_iterator<HEAPENTRYSET> 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<<"The size of the different block is/t"<<(*mpos).dwBlockSize<<"/tand the addresss is/t"<<(*mpos).dwAddress<<"/tdwFlags is/t"<<(*mpos).dwFlags <<endl;
  cout<<"The heapid is:/t"<<(*mpos).th32HeapID <<endl;
 }

 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;
  DWORD 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 :"<<he32.th32HeapID<<endl;
  cout<<"the information of first block: "<< "Blocksize: "<<he32.dwBlockSize<<"/t Address: "<<(LONG)he32.dwAddress<<endl;
  
  if((he32.dwFlags & LF32_FIXED) || (he32.dwFlags & LF32_MOVEABLE))
  hset.push_back(he32);

  while(Heap32Next(&he32))
   {
    cout<< "the information of block: " << "Blocksize: "<<he32.dwBlockSize<<"/t Address: "<<(LONG)he32.dwAddress<<endl;

    totalsize +=he32.dwBlockSize;

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

   }

  cout<<"the total size of heap is: "<<totalsize<<endl;
  cout<<"the free  size of heap is: "<<freesize <<endl;
  cout<<"the commited  size of heap is: "<<(totalsize-freesize)<<endl;

  bRet=Heap32ListNext(hSnapShot,&heaplist32);
 }

 CloseHandle(hSnapShot);

 cout<<"the end"<<endl;
}

0 0

相关博文

我的热门文章

img
取 消
img