KFPSimdAllocator.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file KFPSimdAllocator.h

/*
 * This file is part of KFParticle package
 * Copyright (C) 2007-2019 FIAS Frankfurt Institute for Advanced Studies
 *               2007-2019 Goethe University of Frankfurt
 *               2007-2019 Ivan Kisel <I.Kisel@compeng.uni-frankfurt.de>
 *               2007-2019 Maksym Zyzak
 *
 * KFParticle is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * KFParticle is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef KFPSimdAllocator_H
#define KFPSimdAllocator_H

#include <Vc/Vc>

template <class T>
class KFPSimdAllocator {
 public:
 // type definitions
  typedef T        value_type;
  typedef T*       pointer;
  typedef const T* const_pointer;
  typedef T&       reference;
  typedef const T& const_reference;
  typedef std::size_t    size_type;
  typedef std::ptrdiff_t difference_type;

  template <class U>
  struct rebind {
    typedef KFPSimdAllocator<U> other;
  };

  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
  */
  KFPSimdAllocator() throw() { }
  KFPSimdAllocator(const KFPSimdAllocator&) throw() {  }
  template <class U>
  KFPSimdAllocator (const KFPSimdAllocator<U>&) throw() {  }
  ~KFPSimdAllocator() throw() {  }

  size_type max_size () const throw() {
    return std::numeric_limits<std::size_t>::max() / sizeof(T);
  }

  pointer allocate (size_type num, const void* = 0) {
//               print message and allocate memory with global new
    pointer ret = reinterpret_cast<pointer>( /*T::*/operator new(num*sizeof(T)) );
    return ret;
  }

  void construct (pointer p) {
  // initialize memory with placement new
    new(p) T();
  }
  
  void construct (pointer p, const T& value) {
    new(p) T(value);
  }

  void destroy (pointer p) {
  // destroy objects by calling their destructor
    p->~T();
  }

  void deallocate (pointer p, size_type num) {
  // print message and deallocate memory with global delete
    /*T::*/operator delete(static_cast<void*>(p), num*sizeof(T));

  }

  void *operator new(size_t size, void *ptr) { return ::operator new(size, ptr);}      
  void *operator new[](size_t size, void *ptr) { return ::operator new(size, ptr);}    
  void *operator new(size_t size) { return _mm_malloc(size, sizeof(Vc::float_v)); }    
  void *operator new[](size_t size) { return _mm_malloc(size, sizeof(Vc::float_v)); }  
  void operator delete(void *ptr, size_t) { _mm_free(ptr); }                           
  void operator delete[](void *ptr, size_t) { _mm_free(ptr); }                         
}; // KFPSimdAllocator
      
#endif //KFPSimdAllocator