memory.hpp

Go to the documentation of this file.

#ifndef ALREADY_memory
#define ALREADY_memory
void freeplacemon();
template<typename T>
void INIT_ELEM(void * ptr, int size)
{
  //cout<<"je passe par l'init"<<endl;
  for(unsigned i=0;i<(size/(sizeof(T)));i++)
    new((T*)ptr+i) T;

}
#if 0
template<>
void INIT_ELEM<Z<MON_PREMIER, short int> >(void * ptr, int size)
{
  //cout<<"je passe par l'init"<<endl;
  for(unsigned i=0;i<(size/(sizeof(Z<MON_PREMIER,short int>)));i++)
    {
      new(((Z<MON_PREMIER,short int> *)ptr)+i) Z<MON_PREMIER,short int>;
      *((Z<MON_PREMIER,short int> *)ptr+i)=0;
    }
}
#endif

template<typename T>
void CLEAR_ELEM(void * ptr, int size)
{
  for(unsigned int i=0;i<size/(sizeof(T));i++)
    ((T*)ptr+i)->~T();
}
//#include"mpaispecial.cc"
//#include "mpqspecial.hpp"
//#include "mpfspecial.hpp"
//#include "mpzspecial.hpp"
//#include "modspecial.cpp"

//#ifdef NEED_INIT_ELEM
template<typename T>
inline void * MAC_REV_MALLOC(int size)
{
  //cout<<"c'est celui la "<<endl;
  void * res;
  res=malloc(size);
  INIT_ELEM<T>(res,size);
  return res;
}

template<typename T>
inline void * MAC_REV_REALLOC(void * ptr,int size,int newsize)
{
  void *res=ptr;
  if(size<newsize)
    {
      res=realloc(ptr,newsize);
      INIT_ELEM<T>((char*)res+size,newsize-size);
    }
  if(size>newsize)
    {
      CLEAR_ELEM<T>((char*)ptr+newsize,size-newsize);
      res=realloc(ptr,newsize);
    }
  return res;
}
template<typename T>
inline void MAC_REV_FREE(void * ptr,int size)
{
  if(size>0)
    CLEAR_ELEM<T>(ptr,size);
  free(ptr);
}
#if 0
template<>
void INIT_ELEM<Mon>(void *ptr,int size)
{
  typedef Mon::coeff_t coeff;
  int tmp=size/sizeof(Mon);
  for(int i=0;i<tmp;i++)
    INIT_ELEM<coeff>(&(((Mon*)ptr+i)->coeff),sizeof(coeff));
}

template<>
void CLEAR_ELEM<mon>(void *ptr,int size)
{
  typedef mon::coeff_t coeff;
  int tmp=size/sizeof(mon);
  for(int i=0;i<tmp;i++)
    CLEAR_ELEM<coeff>(&(((mon*)ptr)+i)->coeff,sizeof(coeff));
}
#endif
#if 0
template<typename T>
inline void * MAC_REV_MALLOC(int size)
{
  void * res;
  res=malloc(size);
  return res;
}

template<typename T>
inline void * MAC_REV_REALLOC(void * ptr,int size,int newsize)
{
  void * res;
  res=realloc(ptr,newsize);
  return res;
}
template<typename T>
inline void MAC_REV_FREE(void  * ptr,int size)
{
  free(ptr);
 }
template<>
inline void * MAC_REV_MALLOC<mon>(int size)
{
  void * res;
  res=malloc(size);
  for(int i=0;i<size/sizeof(mon);i++)
    new((mon *)res+i) mon;
  return res;
}

template<>
inline void * MAC_REV_REALLOC<mon>(void * ptr,int size,int newsize)
{
  void *res=ptr;
  int tmp=size/sizeof(mon);
  if(size<newsize)
    {
      res=realloc(ptr,newsize);
      for(int i=0;i<(newsize-size)/sizeof(mon);i++)
    new((mon*)res+tmp+i) mon;
    }
  if(size>newsize)
    {
      for(int i=0;i<(size-newsize)/sizeof(mon);i++)
    ((mon*)res+tmp+i)->~mon();
      res=realloc(ptr,newsize);
    }
  return res;
}

template<>
inline void MAC_REV_FREE<mon>(void  * ptr,int size)
{
 for(int i=0;i<(size)/sizeof(mon);i++)
    ((mon*)ptr+i)->~mon();
  free(ptr);
 }

#endif

template<typename typdump, typename Base>
/*#ifdef unimul 
#ifdef uninf 
void sweep(typdump &dump,Base &b,int **multiple,void**nfmul)
#endif
#else
#ifdef unimul
  void sweep(typdump &dump,Base &b,int **unimul)
#else
#ifdef uninf
  void sweep(typdump &dump,Base &b,void**nfmul)
#else
*/
  void sweep(typdump &dump,Base &b)
//#endif
//#endif
//#endif

{
  typedef typename typdump::value_type::pol_t::coeff_t coeff;
  typedef typename Base::mon mon;
  for(typename typdump::iterator iter=dump.begin()
    ;iter!=dump.end();iter++)
    {
      for(int i=0;i<(iter->size);i++) {
    MAC_REV_FREE<coeff>(iter->nf[i].nf,iter->nf[i].size*sizeof(coeff));
#ifdef sparse
    MAC_REV_FREE<int>(iter->nf[i].nfind,iter->nf[i].size*sizeof(int));
#endif      
      }
      MAC_REV_FREE<pol<mon,coeff> >(iter->nf,iter->size*sizeof(pol<mon,coeff>));
    }
  for(typename Base::iterator iter=b.begin()
    ;iter!=b.end();iter++)
    {
      MAC_REV_FREE<mon>(iter->accept,iter->taille1*sizeof(mon));
      MAC_REV_FREE<mon>(iter->refuse,iter->taille2*sizeof(mon));
    } 
  //freeplacemon();
  
}
#endif //ALREADY_memory