00001 /* 00002 Copyright 2005-2013 Intel Corporation. All Rights Reserved. 00003 00004 This file is part of Threading Building Blocks. 00005 00006 Threading Building Blocks is free software; you can redistribute it 00007 and/or modify it under the terms of the GNU General Public License 00008 version 2 as published by the Free Software Foundation. 00009 00010 Threading Building Blocks is distributed in the hope that it will be 00011 useful, but WITHOUT ANY WARRANTY; without even the implied warranty 00012 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 GNU General Public License for more details. 00014 00015 You should have received a copy of the GNU General Public License 00016 along with Threading Building Blocks; if not, write to the Free Software 00017 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 00018 00019 As a special exception, you may use this file as part of a free software 00020 library without restriction. Specifically, if other files instantiate 00021 templates or use macros or inline functions from this file, or you compile 00022 this file and link it with other files to produce an executable, this 00023 file does not by itself cause the resulting executable to be covered by 00024 the GNU General Public License. This exception does not however 00025 invalidate any other reasons why the executable file might be covered by 00026 the GNU General Public License. 00027 */ 00028 00029 #ifndef __TBB_combinable_H 00030 #define __TBB_combinable_H 00031 00032 #include "enumerable_thread_specific.h" 00033 #include "cache_aligned_allocator.h" 00034 00035 namespace tbb { 00039 00040 00041 template <typename T> 00042 class combinable { 00043 private: 00044 typedef typename tbb::cache_aligned_allocator<T> my_alloc; 00045 00046 typedef typename tbb::enumerable_thread_specific<T, my_alloc, ets_no_key> my_ets_type; 00047 my_ets_type my_ets; 00048 00049 public: 00050 00051 combinable() { } 00052 00053 template <typename finit> 00054 combinable( finit _finit) : my_ets(_finit) { } 00055 00057 ~combinable() { 00058 } 00059 00060 combinable(const combinable& other) : my_ets(other.my_ets) { } 00061 00062 combinable & operator=( const combinable & other) { my_ets = other.my_ets; return *this; } 00063 00064 void clear() { my_ets.clear(); } 00065 00066 T& local() { return my_ets.local(); } 00067 00068 T& local(bool & exists) { return my_ets.local(exists); } 00069 00070 // combine_func_t has signature T(T,T) or T(const T&, const T&) 00071 template <typename combine_func_t> 00072 T combine(combine_func_t f_combine) { return my_ets.combine(f_combine); } 00073 00074 // combine_func_t has signature void(T) or void(const T&) 00075 template <typename combine_func_t> 00076 void combine_each(combine_func_t f_combine) { my_ets.combine_each(f_combine); } 00077 00078 }; 00079 } // namespace tbb 00080 #endif /* __TBB_combinable_H */