GOSTCoin CUDA miner project, compatible with most nvidia cards, containing only gostd algo
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

287 lines
7.2 KiB

/*
* Copyright 2008-2012 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <thrust/detail/config.h>
#include <thrust/detail/allocator/allocator_traits.h>
#include <thrust/detail/type_traits/has_member_function.h>
#include <thrust/detail/type_traits/is_call_possible.h>
#include <new>
#include <limits>
namespace thrust
{
namespace detail
{
namespace allocator_traits_detail
{
__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate)
template<typename Alloc>
class has_member_allocate_with_hint
{
typedef typename allocator_traits<Alloc>::pointer pointer;
typedef typename allocator_traits<Alloc>::size_type size_type;
typedef typename allocator_traits<Alloc>::const_void_pointer const_void_pointer;
public:
typedef typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type,const_void_pointer)>::type type;
static const bool value = type::value;
};
template<typename Alloc>
typename enable_if<
has_member_allocate_with_hint<Alloc>::value,
typename allocator_traits<Alloc>::pointer
>::type
allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
{
return a.allocate(n,hint);
}
template<typename Alloc>
typename disable_if<
has_member_allocate_with_hint<Alloc>::value,
typename allocator_traits<Alloc>::pointer
>::type
allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer)
{
return a.allocate(n);
}
__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct)
template<typename Alloc, typename T>
struct has_member_construct1
: has_member_construct1_impl<Alloc, void(T*)>
{};
template<typename Alloc, typename T>
inline __host__ __device__
typename enable_if<
has_member_construct1<Alloc,T>::value
>::type
construct(Alloc &a, T *p)
{
a.construct(p);
}
template<typename Alloc, typename T>
inline __host__ __device__
typename disable_if<
has_member_construct1<Alloc,T>::value
>::type
construct(Alloc &a, T *p)
{
::new(static_cast<void*>(p)) T();
}
__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct)
template<typename Alloc, typename T, typename Arg1>
struct has_member_construct2
: has_member_construct2_impl<Alloc, void(T*,const Arg1 &)>
{};
template<typename Alloc, typename T, typename Arg1>
inline __host__ __device__
typename enable_if<
has_member_construct2<Alloc,T,Arg1>::value
>::type
construct(Alloc &a, T *p, const Arg1 &arg1)
{
a.construct(p,arg1);
}
template<typename Alloc, typename T, typename Arg1>
inline __host__ __device__
typename disable_if<
has_member_construct2<Alloc,T,Arg1>::value
>::type
construct(Alloc &, T *p, const Arg1 &arg1)
{
::new(static_cast<void*>(p)) T(arg1);
}
__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy)
template<typename Alloc, typename T>
struct has_member_destroy
: has_member_destroy_impl<Alloc, void(T*)>
{};
template<typename Alloc, typename T>
inline __host__ __device__
typename enable_if<
has_member_destroy<Alloc,T>::value
>::type
destroy(Alloc &a, T *p)
{
a.destroy(p);
}
template<typename Alloc, typename T>
inline __host__ __device__
typename disable_if<
has_member_destroy<Alloc,T>::value
>::type
destroy(Alloc &, T *p)
{
p->~T();
}
__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size)
template<typename Alloc>
class has_member_max_size
{
typedef typename allocator_traits<Alloc>::size_type size_type;
public:
typedef typename has_member_max_size_impl<Alloc, size_type(void)>::type type;
static const bool value = type::value;
};
template<typename Alloc>
typename enable_if<
has_member_max_size<Alloc>::value,
typename allocator_traits<Alloc>::size_type
>::type
max_size(const Alloc &a)
{
return a.max_size();
}
template<typename Alloc>
typename disable_if<
has_member_max_size<Alloc>::value,
typename allocator_traits<Alloc>::size_type
>::type
max_size(const Alloc &a)
{
typedef typename allocator_traits<Alloc>::size_type size_type;
return std::numeric_limits<size_type>::max();
}
__THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system)
template<typename Alloc>
class has_member_system
{
typedef typename allocator_system<Alloc>::type system_type;
public:
typedef typename has_member_system_impl<Alloc, system_type&(void)>::type type;
static const bool value = type::value;
};
template<typename Alloc>
typename enable_if<
has_member_system<Alloc>::value,
typename allocator_system<Alloc>::type &
>::type
system(Alloc &a)
{
return a.system();
}
template<typename Alloc>
typename disable_if<
has_member_system<Alloc>::value,
typename allocator_system<Alloc>::type &
>::type
system(Alloc &a)
{
// assumes the system is default-constructible
static typename allocator_system<Alloc>::type state;
return state;
}
} // end allocator_traits_detail
template<typename Alloc>
typename allocator_traits<Alloc>::pointer
allocator_traits<Alloc>
::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
{
return a.allocate(n);
}
template<typename Alloc>
typename allocator_traits<Alloc>::pointer
allocator_traits<Alloc>
::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
{
return allocator_traits_detail::allocate(a, n, hint);
}
template<typename Alloc>
void allocator_traits<Alloc>
::deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
{
return a.deallocate(p,n);
}
template<typename Alloc>
template<typename T>
void allocator_traits<Alloc>
::construct(allocator_type &a, T *p)
{
return allocator_traits_detail::construct(a,p);
}
template<typename Alloc>
template<typename T, typename Arg1>
void allocator_traits<Alloc>
::construct(allocator_type &a, T *p, const Arg1 &arg1)
{
return allocator_traits_detail::construct(a,p,arg1);
}
template<typename Alloc>
template<typename T>
void allocator_traits<Alloc>
::destroy(allocator_type &a, T *p)
{
return allocator_traits_detail::destroy(a,p);
}
template<typename Alloc>
typename allocator_traits<Alloc>::size_type
allocator_traits<Alloc>
::max_size(const allocator_type &a)
{
return allocator_traits_detail::max_size(a);
}
template<typename Alloc>
typename allocator_system<Alloc>::type &
allocator_system<Alloc>
::get(Alloc &a)
{
return allocator_traits_detail::system(a);
}
} // end detail
} // end thrust