Received: by mail.netbsd.org (Postfix, from userid 605) id 0EA3D84DE2; Sat, 5 Sep 2020 11:34:13 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by mail.netbsd.org (Postfix) with ESMTP id 8732F84DE0 for ; Sat, 5 Sep 2020 11:34:12 +0000 (UTC) X-Virus-Scanned: amavisd-new at netbsd.org Received: from mail.netbsd.org ([127.0.0.1]) by localhost (mail.netbsd.org [127.0.0.1]) (amavisd-new, port 10025) with ESMTP id MKIisnWxbr0G for ; Sat, 5 Sep 2020 11:34:08 +0000 (UTC) Received: from cvs.NetBSD.org (ivanova.netbsd.org [199.233.217.197]) by mail.netbsd.org (Postfix) with ESMTP id 4E15284DDD for ; Sat, 5 Sep 2020 11:34:08 +0000 (UTC) Received: by cvs.NetBSD.org (Postfix, from userid 500) id 47207FB28; Sat, 5 Sep 2020 11:34:08 +0000 (UTC) Content-Transfer-Encoding: 7bit Content-Type: multipart/mixed; boundary="_----------=_1599305648255410" MIME-Version: 1.0 Date: Sat, 5 Sep 2020 11:34:08 +0000 From: "Ryo ONODERA" Subject: CVS commit: pkgsrc/parallel/threadingbuildingblocks To: pkgsrc-changes@NetBSD.org Reply-To: ryoon@netbsd.org X-Mailer: log_accum Message-Id: <20200905113408.47207FB28@cvs.NetBSD.org> Sender: pkgsrc-changes-owner@NetBSD.org List-Id: pkgsrc-changes.NetBSD.org Precedence: bulk List-Unsubscribe: This is a multi-part message in MIME format. --_----------=_1599305648255410 Content-Disposition: inline Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII" Module Name: pkgsrc Committed By: ryoon Date: Sat Sep 5 11:34:08 UTC 2020 Modified Files: pkgsrc/parallel/threadingbuildingblocks: Makefile PLIST buildlink3.mk distinfo Removed Files: pkgsrc/parallel/threadingbuildingblocks/patches: patch-build_FreeBSD.gcc.inc Log Message: threadingbuildingblocks: Update to 2020.3 Changelog: Intel TBB 2020 Update 3 TBB_INTERFACE_VERSION == 11103 Changes (w.r.t. Intel TBB 2020 Update 2): Changes affecting backward compatibility: - Changed body type concept of the flow::input_node. Set TBB_DEPRECATED_INPUT_NODE_BODY to 1 to compile with the previous concept of the body type. Bugs fixed: - Fixed compilation errors in C++20 mode due to ambiguity of comparison operators. Inspired by Barry Revzin (https://github.com/oneapi-src/oneTBB/pull/251). Open-source contributions integrated: - Fixed an issue in TBBBuild.cmake that causes the build with no arguments to fail (https://github.com/oneapi-src/oneTBB/pull/233) by tttapa. - Added cmake/{TBBConfig,TBBConfigVersion}.cmake to Git ignore list (https://github.com/oneapi-src/oneTBB/pull/239) by Eisuke Kawashima. ------------------------------------------------------------------------ Intel TBB 2020 Update 2 TBB_INTERFACE_VERSION == 11102 Changes (w.r.t. Intel TBB 2020 Update 1): - Cross-allocator copying constructor and copy assignment operator for concurrent_vector are deprecated. - Added input_node to the flow graph API. It acts like a source_node except for being inactive by default; source_node is deprecated. - Allocator template parameter for flow graph nodes is deprecated. Set TBB_DEPRECATED_FLOW_NODE_ALLOCATOR to 1 to avoid compilation errors. - Flow graph preview hetero-features are deprecated. Bugs fixed: - Fixed the task affinity mechanism to prevent unlimited memory consumption in case the number of threads is explicitly decreased. - Fixed memory leak related NUMA support functionality in task_arena. ------------------------------------------------------------------------ Intel TBB 2020 Update 1 TBB_INTERFACE_VERSION == 11101 Changes (w.r.t. Intel TBB 2020): Preview features: - The NUMA support library (tbbbind) no more depends on the main TBB library. Bugs fixed: - Fixed the issue of task_arena constraints not propagated on copy construction. - Fixed TBBGet.cmake script broken by TBB package name changes (https://github.com/intel/tbb/issues/209). ------------------------------------------------------------------------ Intel TBB 2020 TBB_INTERFACE_VERSION == 11100 Changes (w.r.t. Intel TBB 2019 Update 9): - Extended task_arena interface to simplify development of NUMA-aware applications. - Added warning notifications when the deprecated functionality is used. Open-source contributions integrated: - Fixed various build warnings (https://github.com/intel/tbb/pull/179) by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 2019 Update 9 TBB_INTERFACE_VERSION == 11009 Changes (w.r.t. Intel TBB 2019 Update 8): - Multiple APIs are deprecated. For details, please see Deprecated Features appendix in the TBB reference manual. - Added C++17 deduction guides for flow graph nodes. Preview Features: - Added isolated_task_group class that allows multiple threads to add and execute tasks sharing the same isolation. - Extended the flow graph API to simplify connecting nodes. - Added erase() by heterogeneous keys for concurrent ordered containers. - Added a possibility to suspend task execution at a specific point and resume it later. Bugs fixed: - Fixed the emplace() method of concurrent unordered containers to destroy a temporary element that was not inserted. - Fixed a bug in the merge() method of concurrent unordered containers. - Fixed behavior of a continue_node that follows buffering nodes. - Fixed compilation error caused by missed stdlib.h when CMake integration is used (https://github.com/intel/tbb/issues/195). Inspired by Andrew Penkrat. Open-source contributions integrated: - Added support for move-only types to tbb::parallel_pipeline (https://github.com/intel/tbb/pull/159) by Raf Schietekat. - Fixed detection of clang version when CUDA toolkit is installed (https://github.com/intel/tbb/pull/150) by Guilherme Amadio. ------------------------------------------------------------------------ Intel TBB 2019 Update 8 TBB_INTERFACE_VERSION == 11008 Changes (w.r.t. Intel TBB 2019 Update 7): Bugs fixed: - Fixed a bug in TBB 2019 Update 7 that could lead to incorrect memory reallocation on Linux (https://github.com/intel/tbb/issues/148). - Fixed enqueuing tbb::task into tbb::task_arena not to fail on threads with no task scheduler initialized (https://github.com/intel/tbb/issues/116). ------------------------------------------------------------------------ Intel TBB 2019 Update 7 TBB_INTERFACE_VERSION == 11007 Changes (w.r.t. Intel TBB 2019 Update 6): - Added TBBMALLOC_SET_HUGE_SIZE_THRESHOLD parameter to set the lower bound for allocations that are not released back to OS unless a cleanup is explicitly requested. - Added zip_iterator::base() method to get the tuple of underlying iterators. - Improved async_node to never block a thread that sends a message through its gateway. - Extended decrement port of the tbb::flow::limiter_node to accept messages of integral types. - Added support of Windows* to the CMake module TBBInstallConfig. - Added packaging of CMake configuration files to TBB packages built using build/build.py script (https://github.com/intel/tbb/issues/141). Changes affecting backward compatibility: - Removed the number_of_decrement_predecessors parameter from the constructor of flow::limiter_node. To allow its usage, set TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR macro to 1. Preview Features: - Added ordered associative containers: concurrent_{map,multimap,set,multiset} (requires C++11). Open-source contributions integrated: - Fixed makefiles to properly obtain the GCC version for GCC 7 and later (https://github.com/intel/tbb/pull/147) by Timmmm. ------------------------------------------------------------------------ Intel TBB 2019 Update 6 TBB_INTERFACE_VERSION == 11006 Changes (w.r.t. Intel TBB 2019 Update 5): - Added support for Microsoft* Visual Studio* 2019. - Added support for enqueuing tbb::task into tbb::task_arena (https://github.com/01org/tbb/issues/116). - Improved support for allocator propagation on concurrent_hash_map assigning and swapping. - Improved scalable_allocation_command cleanup operations to release more memory buffered by the calling thread. - Separated allocation of small and large objects into distinct memory regions, which helps to reduce excessive memory caching inside the TBB allocator. Preview Features: - Removed template class gfx_factory from the flow graph API. ------------------------------------------------------------------------ Intel TBB 2019 Update 5 TBB_INTERFACE_VERSION == 11005 Changes (w.r.t. Intel TBB 2019 Update 4): - Associating a task_scheduler_observer with an implicit or explicit task arena is now a fully supported feature. - Added a CMake module TBBInstallConfig that allows to generate and install CMake configuration files for TBB packages. Inspired by Hans Johnson (https://github.com/01org/tbb/pull/119). - Added node handles, methods merge() and unsafe_extract() to concurrent unordered containers. - Added constructors with Compare argument to concurrent_priority_queue (https://github.com/01org/tbb/issues/109). - Controlling the stack size of worker threads is now supported for Universal Windows Platform. - Improved tbb::zip_iterator to work with algorithms that swap values via iterators. - Improved support for user-specified allocators in concurrent_hash_map, including construction of allocator-aware data types. - For ReaderWriterMutex types, upgrades and downgrades now succeed if the mutex is already in the requested state. Inspired by Niadb (https://github.com/01org/tbb/pull/122). Preview Features: - The task_scheduler_observer::may_sleep() method has been removed. Bugs fixed: - Fixed the issue with a pipeline parallel filter executing serially if it follows a thread-bound filter. - Fixed a performance regression observed when multiple parallel algorithms start simultaneously. ------------------------------------------------------------------------ Intel TBB 2019 Update 4 TBB_INTERFACE_VERSION == 11004 Changes (w.r.t. Intel TBB 2019 Update 3): - global_control class is now a fully supported feature. - Added deduction guides for tbb containers: concurrent_hash_map, concurrent_unordered_map, concurrent_unordered_set. - Added tbb::scalable_memory_resource function returning std::pmr::memory_resource interface to the TBB memory allocator. - Added tbb::cache_aligned_resource class that implements std::pmr::memory_resource with cache alignment and no false sharing. - Added rml::pool_msize function returning the usable size of a memory block allocated from a given memory pool. - Added default and copy constructors for tbb::counting_iterator and tbb::zip_iterator. - Added TBB_malloc_replacement_log function to obtain the status of dynamic memory allocation replacement (Windows* only). - CMake configuration file now supports release-only and debug-only configurations (https://github.com/01org/tbb/issues/113). - TBBBuild CMake module takes the C++ version from CMAKE_CXX_STANDARD. Bugs fixed: - Fixed compilation for tbb::concurrent_vector when used with std::pmr::polymorphic_allocator. Open-source contributions integrated: - TBB_INTERFACE_VERSION is included into TBB version in CMake configuration (https://github.com/01org/tbb/pull/100) by Hans Johnson. - Fixed detection of C++17 deduction guides for Visual C++* (https://github.com/01org/tbb/pull/112) by Marian Klymov. ------------------------------------------------------------------------ Intel TBB 2019 Update 3 TBB_INTERFACE_VERSION == 11003 Changes (w.r.t. Intel TBB 2019 Update 2): - Added tbb::transform_iterator. - Added new Makefile target 'profile' to flow graph examples enabling additional support for Intel(R) Parallel Studio XE tools. - Added TBB_MALLOC_DISABLE_REPLACEMENT environment variable to switch off dynamic memory allocation replacement on Windows*. Inspired by a contribution from Edward Lam. Preview Features: - Extended flow graph API to support relative priorities for functional nodes, specified as an optional parameter to the node constructors. Open-source contributions integrated: - Enabled using process-local futex operations (https://github.com/01org/tbb/pull/58) by Andrey Semashev. ------------------------------------------------------------------------ Intel TBB 2019 Update 2 TBB_INTERFACE_VERSION == 11002 Changes (w.r.t. Intel TBB 2019 Update 1): - Added overloads for parallel_reduce with default partitioner and user-supplied context. - Added deduction guides for tbb containers: concurrent_vector, concurrent_queue, concurrent_bounded_queue, concurrent_priority_queue. - Reallocation of memory objects >1MB now copies and frees memory if the size is decreased twice or more, trading performance off for reduced memory usage. - After a period of sleep, TBB worker threads now prefer returning to their last used task arena. Bugs fixed: - Fixed compilation of task_group.h when targeting macOS* 10.11 or earlier (https://github.com/conda-forge/tbb-feedstock/issues/42). Open-source contributions integrated: - Added constructors with HashCompare argument to concurrent_hash_map (https://github.com/01org/tbb/pull/63) by arewedancer. ------------------------------------------------------------------------ Intel TBB 2019 Update 1 TBB_INTERFACE_VERSION == 11001 Changes (w.r.t. Intel TBB 2019): - Doxygen documentation could be built with 'make doxygen' command now. Changes affecting backward compatibility: - Enforced 8 byte alignment for tbb::atomic and tbb::atomic. On IA-32 architecture it may cause layout changes in structures that use these types. Bugs fixed: - Fixed an issue with dynamic memory allocation replacement on Windows* occurred for some versions of ucrtbase.dll. - Fixed possible deadlock in tbbmalloc cleanup procedure during process shutdown. Inspired by a contribution from Edward Lam. - Fixed usage of std::uncaught_exception() deprecated in C++17 (https://github.com/01org/tbb/issues/67). - Fixed a crash when a local observer is activated after an arena observer. - Fixed compilation of task_group.h by Visual C++* 15.7 with /permissive- option (https://github.com/01org/tbb/issues/53). - Fixed tbb4py to avoid dependency on Intel(R) C++ Compiler shared libraries. - Fixed compilation for Anaconda environment with GCC 7.3 and higher. Open-source contributions integrated: - Fix various warnings when building with Visual C++ (https://github.com/01org/tbb/pull/70) by Edward Lam. ------------------------------------------------------------------------ Intel TBB 2019 TBB_INTERFACE_VERSION == 11000 Changes (w.r.t. Intel TBB 2018 Update 5): - Lightweight policy for functional nodes in the flow graph is now a fully supported feature. - Reservation support in flow::write_once_node and flow::overwrite_node is now a fully supported feature. - Support for Flow Graph Analyzer and improvements for Intel(R) VTune(TM) Amplifier become a regular feature enabled by TBB_USE_THREADING_TOOLS macro. - Added support for std::new_handler in the replacement functions for global operator new. - Added C++14 constructors to concurrent unordered containers. - Added tbb::counting_iterator and tbb::zip_iterator. - Fixed multiple -Wextra warnings in TBB source files. Preview Features: - Extracting nodes from a flow graph is deprecated and disabled by default. To enable, use TBB_DEPRECATED_FLOW_NODE_EXTRACTION macro. Changes affecting backward compatibility: - Due to internal changes in the flow graph classes, recompilation is recommended for all binaries that use the flow graph. Open-source contributions integrated: - Added support for OpenBSD by Anthony J. Bentley. ------------------------------------------------------------------------ Intel TBB 2018 Update 6 TBB_INTERFACE_VERSION == 10006 Changes (w.r.t. Intel TBB 2018 Update 5): Bugs fixed: - Fixed an issue with dynamic memory allocation replacement on Windows* occurred for some versions of ucrtbase.dll. ------------------------------------------------------------------------ Intel TBB 2018 Update 5 TBB_INTERFACE_VERSION == 10005 Changes (w.r.t. Intel TBB 2018 Update 4): Preview Features: - Added user event tracing API for Intel(R) VTune(TM) Amplifier and Flow Graph Analyzer. Bugs fixed: - Fixed the memory allocator to properly support transparent huge pages. - Removed dynamic exception specifications in tbbmalloc_proxy for C++11 and later (https://github.com/01org/tbb/issues/41). - Added -flifetime-dse=1 option when building with GCC on macOS* (https://github.com/01org/tbb/issues/60). Open-source contributions integrated: - Added ARMv8 support by Siddhesh Poyarekar. - Avoid GCC warnings for clearing an object of non-trivial type (https://github.com/01org/tbb/issues/54) by Daniel Arndt. ------------------------------------------------------------------------ Intel TBB 2018 Update 4 TBB_INTERFACE_VERSION == 10004 Changes (w.r.t. Intel TBB 2018 Update 3): Preview Features: - Improved support for Flow Graph Analyzer and Intel(R) VTune(TM) Amplifier in the task scheduler and generic parallel algorithms. - Default device set for opencl_node now includes all the devices from the first available OpenCL* platform. - Added lightweight policy for functional nodes in the flow graph. It indicates that the node body has little work and should, if possible, be executed immediately upon receiving a message, avoiding task scheduling overhead. ------------------------------------------------------------------------ Intel TBB 2018 Update 3 TBB_INTERFACE_VERSION == 10003 Changes (w.r.t. Intel TBB 2018 Update 2): Preview Features: - Added template class blocked_rangeNd for a generic multi-dimensional range (requires C++11). Inspired by a contribution from Jeff Hammond. Bugs fixed: - Fixed a crash with dynamic memory allocation replacement on Windows* for applications using system() function. - Fixed parallel_deterministic_reduce to split range correctly when used with static_partitioner. - Fixed a synchronization issue in task_group::run_and_wait() which caused a simultaneous call to task_group::wait() to return prematurely. ------------------------------------------------------------------------ Intel TBB 2018 Update 2 TBB_INTERFACE_VERSION == 10002 Changes (w.r.t. Intel TBB 2018 Update 1): - Added support for Android* NDK r16, macOS* 10.13, Fedora* 26. - Binaries for Universal Windows Driver (vc14_uwd) now link with static Microsoft* runtime libraries, and are only available in commercial releases. - Extended flow graph documentation with more code samples. Preview Features: - Added a Python* module for multi-processing computations in numeric Python* libraries. Bugs fixed: - Fixed constructors of concurrent_hash_map to be exception-safe. - Fixed auto-initialization in the main thread to be cleaned up at shutdown. - Fixed a crash when tbbmalloc_proxy is used together with dbghelp. - Fixed static_partitioner to assign tasks properly in case of nested parallelism. ------------------------------------------------------------------------ Intel TBB 2018 Update 1 TBB_INTERFACE_VERSION == 10001 Changes (w.r.t. Intel TBB 2018): - Added lambda-friendly overloads for parallel_scan. - Added support of static and simple partitioners in parallel_deterministic_reduce. Preview Features: - Added initial support for Flow Graph Analyzer to parallel_for. - Added reservation support in overwrite_node and write_once_node. Bugs fixed: - Fixed a potential deadlock scenario in the flow graph that affected Intel TBB 2018. ------------------------------------------------------------------------ Intel TBB 2018 TBB_INTERFACE_VERSION == 10000 Changes (w.r.t. Intel TBB 2017 Update 7): - Introduced Parallel STL, an implementation of the C++ standard library algorithms with support for execution policies. For more information, see Getting Started with Parallel STL (https://software.intel.com/en-us/get-started-with-pstl). - this_task_arena::isolate() function is now a fully supported feature. - this_task_arena::isolate() function and task_arena::execute() method were extended to pass on the value returned by the executed functor (requires C++11). - task_arena::enqueue() and task_group::run() methods extended to accept move-only functors. - A flow graph now spawns all tasks into the same task arena, and waiting for graph completion also happens in that arena. - Improved support for Flow Graph Analyzer in async_node, opencl_node, and composite_node. - Added support for Android* NDK r15, r15b. - Added support for Universal Windows Platform. - Increased minimally supported version of macOS* (MACOSX_DEPLOYMENT_TARGET) to 10.11. Changes affecting backward compatibility: - Internal layout changes in some flow graph classes; - Several undocumented methods are removed from class graph, including set_active() and is_active(). - Due to incompatible changes, the namespace version is updated for the flow graph; recompilation is recommended for all binaries that use the flow graph classes. Preview Features: - opencl_node can be used with any graph object; class opencl_graph is removed. - graph::wait_for_all() now automatically waits for all not yet consumed async_msg objects. - Improved concurrent_lru_cache::handle_object to support C++11 move semantics, default construction, and conversion to bool. Bugs fixed: - Fixed a bug preventing use of streaming_node and opencl_node with Clang; inspired by a contribution from Francisco Facioni. - Fixed this_task_arena::isolate() function to work correctly with parallel_invoke and parallel_do algorithms. - Fixed a memory leak in composite_node. - Fixed an assertion failure in debug tbbmalloc binaries when TBBMALLOC_CLEAN_ALL_BUFFERS is used. ------------------------------------------------------------------------ Intel TBB 2017 Update 8 TBB_INTERFACE_VERSION == 9108 Changes (w.r.t. Intel TBB 2017 Update 7): Bugs fixed: - Fixed an assertion failure in debug tbbmalloc binaries when TBBMALLOC_CLEAN_ALL_BUFFERS is used. ------------------------------------------------------------------------ Intel TBB 2017 Update 7 TBB_INTERFACE_VERSION == 9107 Changes (w.r.t. Intel TBB 2017 Update 6): - In the huge pages mode, the memory allocator now is also able to use transparent huge pages. Preview Features: - Added support for Intel TBB integration into CMake-aware projects, with valuable guidance and feedback provided by Brad King (Kitware). Bugs fixed: - Fixed scalable_allocation_command(TBBMALLOC_CLEAN_ALL_BUFFERS, 0) to process memory left after exited threads. ------------------------------------------------------------------------ Intel TBB 2017 Update 6 TBB_INTERFACE_VERSION == 9106 Changes (w.r.t. Intel TBB 2017 Update 5): - Added support for Android* NDK r14. Preview Features: - Added a blocking terminate extension to the task_scheduler_init class that allows an object to wait for termination of worker threads. Bugs fixed: - Fixed compilation and testing issues with MinGW (GCC 6). - Fixed compilation with /std:c++latest option of VS 2017 (https://github.com/01org/tbb/issues/13). ------------------------------------------------------------------------ Intel TBB 2017 Update 5 TBB_INTERFACE_VERSION == 9105 Changes (w.r.t. Intel TBB 2017 Update 4): - Added support for Microsoft* Visual Studio* 2017. - Added graph/matmult example to demonstrate support for compute offload to Intel(R) Graphics Technology in the flow graph API. - The "compiler" build option now allows to specify a full path to the compiler. Changes affecting backward compatibility: - Constructors for many classes, including graph nodes, concurrent containers, thread-local containers, etc., are declared explicit and cannot be used for implicit conversions anymore. Bugs fixed: - Added a workaround for bug 16657 in the GNU C Library (glibc) affecting the debug version of tbb::mutex. - Fixed a crash in pool_identify() called for an object allocated in another thread. ------------------------------------------------------------------------ Intel TBB 2017 Update 4 TBB_INTERFACE_VERSION == 9104 Changes (w.r.t. Intel TBB 2017 Update 3): - Added support for C++11 move semantics in parallel_do. - Added support for FreeBSD* 11. Changes affecting backward compatibility: - Minimal compiler versions required for support of C++11 move semantics raised to GCC 4.5, VS 2012, and Intel(R) C++ Compiler 14.0. Bugs fixed: - The workaround for crashes in the library compiled with GCC 6 (-flifetime-dse=1) was extended to Windows*. ------------------------------------------------------------------------ Intel TBB 2017 Update 3 TBB_INTERFACE_VERSION == 9103 Changes (w.r.t. Intel TBB 2017 Update 2): - Added support for Android* 7.0 and Android* NDK r13, r13b. Preview Features: - Added template class gfx_factory to the flow graph API. It implements the Factory concept for streaming_node to offload computations to Intel(R) processor graphics. Bugs fixed: - Fixed a possible deadlock caused by missed wakeup signals in task_arena::execute(). Open-source contributions integrated: - A build fix for Linux* s390x platform by Jerry J. ------------------------------------------------------------------------ Intel TBB 2017 Update 2 TBB_INTERFACE_VERSION == 9102 Changes (w.r.t. Intel TBB 2017 Update 1): - Removed the long-outdated support for Xbox* consoles. Bugs fixed: - Fixed the issue with task_arena::execute() not being processed when the calling thread cannot join the arena. - Fixed dynamic memory allocation replacement failure on macOS* 10.12. ------------------------------------------------------------------------ Intel TBB 2017 Update 1 TBB_INTERFACE_VERSION == 9101 Changes (w.r.t. Intel TBB 2017): Bugs fixed: - Fixed dynamic memory allocation replacement failures on Windows* 10 Anniversary Update. - Fixed emplace() method of concurrent unordered containers to not require a copy constructor. ------------------------------------------------------------------------ Intel TBB 2017 TBB_INTERFACE_VERSION == 9100 Changes (w.r.t. Intel TBB 4.4 Update 5): - static_partitioner class is now a fully supported feature. - async_node class is now a fully supported feature. - Improved dynamic memory allocation replacement on Windows* OS to skip DLLs for which replacement cannot be done, instead of aborting. - Intel TBB no longer performs dynamic memory allocation replacement for Microsoft* Visual Studio* 2008. - For 64-bit platforms, quadrupled the worst-case limit on the amount of memory the Intel TBB allocator can handle. - Added TBB_USE_GLIBCXX_VERSION macro to specify the version of GNU libstdc++ when it cannot be properly recognized, e.g. when used with Clang on Linux* OS. Inspired by a contribution from David A. - Added graph/stereo example to demonstrate tbb::flow::async_msg. - Removed a few cases of excessive user data copying in the flow graph. - Reworked split_node to eliminate unnecessary overheads. - Added support for C++11 move semantics to the argument of tbb::parallel_do_feeder::add() method. - Added C++11 move constructor and assignment operator to tbb::combinable template class. - Added tbb::this_task_arena::max_concurrency() function and max_concurrency() method of class task_arena returning the maximal number of threads that can work inside an arena. - Deprecated tbb::task_arena::current_thread_index() static method; use tbb::this_task_arena::current_thread_index() function instead. - All examples for commercial version of library moved online: https://software.intel.com/en-us/product-code-samples. Examples are available as a standalone package or as a part of Intel(R) Parallel Studio XE or Intel(R) System Studio Online Samples packages. Changes affecting backward compatibility: - Renamed following methods and types in async_node class: Old New async_gateway_type => gateway_type async_gateway() => gateway() async_try_put() => try_put() async_reserve() => reserve_wait() async_commit() => release_wait() - Internal layout of some flow graph nodes has changed; recompilation is recommended for all binaries that use the flow graph. Preview Features: - Added template class streaming_node to the flow graph API. It allows a flow graph to offload computations to other devices through streaming or offloading APIs. - Template class opencl_node reimplemented as a specialization of streaming_node that works with OpenCL*. - Added tbb::this_task_arena::isolate() function to isolate execution of a group of tasks or an algorithm from other tasks submitted to the scheduler. Bugs fixed: - Added a workaround for GCC bug #62258 in std::rethrow_exception() to prevent possible problems in case of exception propagation. - Fixed parallel_scan to provide correct result if the initial value of an accumulator is not the operation identity value. - Fixed a memory corruption in the memory allocator when it meets internal limits. - Fixed the memory allocator on 64-bit platforms to align memory to 16 bytes by default for all allocations bigger than 8 bytes. - As a workaround for crashes in the Intel TBB library compiled with GCC 6, added -flifetime-dse=1 to compilation options on Linux* OS. - Fixed a race in the flow graph implementation. Open-source contributions integrated: - Enabling use of C++11 'override' keyword by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.4 Update 6 TBB_INTERFACE_VERSION == 9006 Changes (w.r.t. Intel TBB 4.4 Update 5): - For 64-bit platforms, quadrupled the worst-case limit on the amount of memory the Intel TBB allocator can handle. Bugs fixed: - Fixed a memory corruption in the memory allocator when it meets internal limits. - Fixed the memory allocator on 64-bit platforms to align memory to 16 bytes by default for all allocations bigger than 8 bytes. - Fixed parallel_scan to provide correct result if the initial value of an accumulator is not the operation identity value. - As a workaround for crashes in the Intel TBB library compiled with GCC 6, added -flifetime-dse=1 to compilation options on Linux* OS. ------------------------------------------------------------------------ Intel TBB 4.4 Update 5 TBB_INTERFACE_VERSION == 9005 Changes (w.r.t. Intel TBB 4.4 Update 4): - Modified graph/fgbzip2 example to remove unnecessary data queuing. Preview Features: - Added a Python* module which is able to replace Python's thread pool class with the implementation based on Intel TBB task scheduler. Bugs fixed: - Fixed the implementation of 64-bit tbb::atomic for IA-32 architecture to work correctly with GCC 5.2 in C++11/14 mode. - Fixed a possible crash when tasks with affinity (e.g. specified via affinity_partitioner) are used simultaneously with task priority changes. ------------------------------------------------------------------------ Intel TBB 4.4 Update 4 TBB_INTERFACE_VERSION == 9004 Changes (w.r.t. Intel TBB 4.4 Update 3): - Removed a few cases of excessive user data copying in the flow graph. - Improved robustness of concurrent_bounded_queue::abort() in case of simultaneous push and pop operations. Preview Features: - Added tbb::flow::async_msg, a special message type to support communications between the flow graph and external asynchronous activities. - async_node modified to support use with C++03 compilers. Bugs fixed: - Fixed a bug in dynamic memory allocation replacement for Windows* OS. - Fixed excessive memory consumption on Linux* OS caused by enabling zero-copy realloc. - Fixed performance regression on Intel(R) Xeon Phi(tm) coprocessor with auto_partitioner. ------------------------------------------------------------------------ Intel TBB 4.4 Update 3 TBB_INTERFACE_VERSION == 9003 Changes (w.r.t. Intel TBB 4.4 Update 2): - Modified parallel_sort to not require a default constructor for values and to use iter_swap() for value swapping. - Added support for creating or initializing a task_arena instance that is connected to the arena currently used by the thread. - graph/binpack example modified to use multifunction_node. - For performance analysis, use Intel(R) VTune(TM) Amplifier XE 2015 and higher; older versions are no longer supported. - Improved support for compilation with disabled RTTI, by omitting its use in auxiliary code, such as assertions. However some functionality, particularly the flow graph, does not work if RTTI is disabled. - The tachyon example for Android* can be built using Android Studio 1.5 and higher with experimental Gradle plugin 0.4.0. Preview Features: - Added class opencl_subbufer that allows using OpenCL* sub-buffer objects with opencl_node. - Class global_control supports the value of 1 for max_allowed_parallelism. Bugs fixed: - Fixed a race causing "TBB Warning: setaffinity syscall failed" message. - Fixed a compilation issue on OS X* with Intel(R) C++ Compiler 15.0. - Fixed a bug in queuing_rw_mutex::downgrade() that could temporarily block new readers. - Fixed speculative_spin_rw_mutex to stop using the lazy subscription technique due to its known flaws. - Fixed memory leaks in the tool support code. ------------------------------------------------------------------------ Intel TBB 4.4 Update 2 TBB_INTERFACE_VERSION == 9002 Changes (w.r.t. Intel TBB 4.4 Update 1): - Improved interoperability with Intel(R) OpenMP RTL (libiomp) on Linux: OpenMP affinity settings do not affect the default number of threads used in the task scheduler. Intel(R) C++ Compiler 16.0 Update 1 or later is required. - Added a new flow graph example with different implementations of the Cholesky Factorization algorithm. Preview Features: - Added template class opencl_node to the flow graph API. It allows a flow graph to offload computations to OpenCL* devices. - Extended join_node to use type-specified message keys. It simplifies the API of the node by obtaining message keys via functions associated with the message type (instead of node ports). - Added static_partitioner that minimizes overhead of parallel_for and parallel_reduce for well-balanced workloads. - Improved template class async_node in the flow graph API to support user settable concurrency limits. Bugs fixed: - Fixed a possible crash in the GUI layer for library examples on Linux. ------------------------------------------------------------------------ Intel TBB 4.4 Update 1 TBB_INTERFACE_VERSION == 9001 Changes (w.r.t. Intel TBB 4.4): - Added support for Microsoft* Visual Studio* 2015. - Intel TBB no longer performs dynamic replacement of memory allocation functions for Microsoft Visual Studio 2005 and earlier versions. - For GCC 4.7 and higher, the intrinsics-based platform isolation layer uses __atomic_* built-ins instead of the legacy __sync_* ones. This change is inspired by a contribution from Mathieu Malaterre. - Improvements in task_arena: Several application threads may join a task_arena and execute tasks simultaneously. The amount of concurrency reserved for application threads at task_arena construction can be set to any value between 0 and the arena concurrency limit. - The fractal example was modified to demonstrate class task_arena and moved to examples/task_arena/fractal. Bugs fixed: - Fixed a deadlock during destruction of task_scheduler_init objects when one of destructors is set to wait for worker threads. - Added a workaround for a possible crash on OS X* when dynamic memory allocator replacement (libtbbmalloc_proxy) is used and memory is released during application startup. - Usage of mutable functors with task_group::run_and_wait() and task_arena::enqueue() is disabled. An attempt to pass a functor which operator()() is not const will produce compilation errors. - Makefiles and environment scripts now properly recognize GCC 5.0 and higher. Open-source contributions integrated: - Improved performance of parallel_for_each for inputs allowing random access, by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.4 TBB_INTERFACE_VERSION == 9000 Changes (w.r.t. Intel TBB 4.3 Update 6): - The following features are now fully supported: tbb::flow::composite_node; additional policies of tbb::flow::graph_node::reset(). - Platform abstraction layer for Windows* OS updated to use compiler intrinsics for most atomic operations. - The tbb/compat/thread header updated to automatically include C++11 where available. - Fixes and refactoring in the task scheduler and class task_arena. - Added key_matching policy to tbb::flow::join_node, which removes the restriction on the type that can be compared-against. - For tag_matching join_node, tag_value is redefined to be 64 bits wide on all architectures. - Expanded the documentation for the flow graph with details about node semantics and behavior. - Added dynamic replacement of C11 standard function aligned_alloc() under Linux* OS. - Added C++11 move constructors and assignment operators to tbb::enumerable_thread_specific container. - Added hashing support for tbb::tbb_thread::id. - On OS X*, binaries that depend on libstdc++ are not provided anymore. In the makefiles, libc++ is now used by default; for building with libstdc++, specify stdlib=libstdc++ in the make command line. Preview Features: - Added a new example, graph/fgbzip2, that shows usage of tbb::flow::async_node. - Modification to the low-level API for memory pools: added a function for finding a memory pool by an object allocated from that pool. - tbb::memory_pool now does not request memory till the first allocation from the pool. Changes affecting backward compatibility: - Internal layout of flow graph nodes has changed; recompilation is recommended for all binaries that use the flow graph. - Resetting a tbb::flow::source_node will immediately activate it, unless it was created in inactive state. Bugs fixed: - Failure at creation of a memory pool will not cause process termination anymore. Open-source contributions integrated: - Supported building TBB with Clang on AArch64 with use of built-in intrinsics by David A. ------------------------------------------------------------------------ Intel TBB 4.3 Update 6 TBB_INTERFACE_VERSION == 8006 Changes (w.r.t. Intel TBB 4.3 Update 5): - Supported zero-copy realloc for objects >1MB under Linux* via mremap system call. - C++11 move-aware insert and emplace methods have been added to concurrent_hash_map container. - install_name is set to @rpath/ on OS X*. Preview Features: - Added template class async_node to the flow graph API. It allows a flow graph to communicate with an external activity managed by the user or another runtime. - Improved speed of flow::graph::reset() clearing graph edges. rf_extract flag has been renamed rf_clear_edges. - extract() method of graph nodes now takes no arguments. Bugs fixed: - concurrent_unordered_{set,map} behaves correctly for degenerate hashes. - Fixed a race condition in the memory allocator that may lead to excessive memory consumption under high multithreading load. ------------------------------------------------------------------------ Intel TBB 4.3 Update 5 TBB_INTERFACE_VERSION == 8005 Changes (w.r.t. Intel TBB 4.3 Update 4): - Added add_ref_count() method of class tbb::task. Preview Features: - Added class global_control for application-wide control of allowed parallelism and thread stack size. - memory_pool_allocator now throws the std::bad_alloc exception on allocation failure. - Exceptions thrown for by memory pool constructors changed from std::bad_alloc to std::invalid_argument and std::runtime_error. Bugs fixed: - scalable_allocator now throws the std::bad_alloc exception on allocation failure. - Fixed a race condition in the memory allocator that may lead to excessive memory consumption under high multithreading load. - A new scheduler created right after destruction of the previous one might be unable to modify the number of worker threads. Open-source contributions integrated: - (Added but not enabled) push_front() method of class tbb::task_list by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.3 Update 4 TBB_INTERFACE_VERSION == 8004 Changes (w.r.t. Intel TBB 4.3 Update 3): - Added a C++11 variadic constructor for enumerable_thread_specific. The arguments from this constructor are used to construct thread-local values. - Improved exception safety for enumerable_thread_specific. - Added documentation for tbb::flow::tagged_msg class and tbb::flow::output_port function. - Fixed build errors for systems that do not support dynamic linking. - C++11 move-aware insert and emplace methods have been added to concurrent unordered containers. Preview Features: - Interface-breaking change: typedefs changed for node predecessor and successor lists, affecting copy_predecessors and copy_successors methods. - Added template class composite_node to the flow graph API. It packages a subgraph to represent it as a first-class flow graph node. - make_edge and remove_edge now accept multiport nodes as arguments, automatically using the node port with index 0 for an edge. Open-source contributions integrated: - Draft code for enumerable_thread_specific constructor with multiple arguments (see above) by Adrien Guinet. - Fix for GCC invocation on IBM* Blue Gene* by Jeff Hammond and Raf Schietekat. - Extended testing with smart pointers for Clang & libc++ by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.3 Update 3 TBB_INTERFACE_VERSION == 8003 Changes (w.r.t. Intel TBB 4.3 Update 2): - Move constructor and assignment operator were added to unique_lock. Preview Features: - Time overhead for memory pool destruction was reduced. Open-source contributions integrated: - Build error fix for iOS* by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.3 Update 2 TBB_INTERFACE_VERSION == 8002 Changes (w.r.t. Intel TBB 4.3 Update 1): - Binary files for 64-bit Android* applications were added as part of the Linux* OS package. - Exact exception propagation is enabled for Intel C++ Compiler on OS X*. - concurrent_vector::shrink_to_fit was optimized for types that support C++11 move semantics. Bugs fixed: - Fixed concurrent unordered containers to insert elements much faster in debug mode. - Fixed concurrent priority queue to support types that do not have copy constructors. - Fixed enumerable_thread_specific to forbid copying from an instance with a different value type. Open-source contributions integrated: - Support for PathScale* EKOPath* Compiler by Erik Lindahl. ------------------------------------------------------------------------ Intel TBB 4.3 Update 1 TBB_INTERFACE_VERSION == 8001 Changes (w.r.t. Intel TBB 4.3): - The ability to split blocked_ranges in a proportion, used by affinity_partitioner since version 4.2 Update 4, became a formal extension of the Range concept. - More checks for an incorrect address to release added to the debug version of the memory allocator. - Different kind of solutions for each TBB example were merged. Preview Features: - Task priorities are re-enabled in preview binaries. Bugs fixed: - Fixed a duplicate symbol when TBB_PREVIEW_VARIADIC_PARALLEL_INVOKE is used in multiple compilation units. - Fixed a crash in __itt_fini_ittlib seen on Ubuntu 14.04. - Fixed a crash in memory release after dynamic replacement of the OS X* memory allocator. - Fixed incorrect indexing of arrays in seismic example. - Fixed a data race in lazy initialization of task_arena. Open-source contributions integrated: - Fix for dumping information about gcc and clang compiler versions by Misty De Meo. ------------------------------------------------------------------------ Intel TBB 4.3 TBB_INTERFACE_VERSION == 8000 Changes (w.r.t. Intel TBB 4.2 Update 5): - The following features are now fully supported: flow::indexer_node, task_arena, speculative_spin_rw_mutex. - Compatibility with C++11 standard improved for tbb/compat/thread and tbb::mutex. - C++11 move constructors have been added to concurrent_queue and concurrent_bounded_queue. - C++11 move constructors and assignment operators have been added to concurrent_vector, concurrent_hash_map, concurrent_priority_queue, concurrent_unordered_{set,multiset,map,multimap}. - C++11 move-aware emplace/push/pop methods have been added to concurrent_vector, concurrent_queue, concurrent_bounded_queue, concurrent_priority_queue. - Methods to insert a C++11 initializer list have been added: concurrent_vector::grow_by(), concurrent_hash_map::insert(), concurrent_unordered_{set,multiset,map,multimap}::insert(). - Testing for compatibility of containers with some C++11 standard library types has been added. - Dynamic replacement of standard memory allocation routines has been added for OS X*. - Microsoft* Visual Studio* projects for Intel TBB examples updated to VS 2010. - For open-source packages, debugging information (line numbers) in precompiled binaries now matches the source code. - Debug information was added to release builds for OS X*, Solaris*, FreeBSD* operating systems and MinGW*. - Various improvements in documentation, debug diagnostics and examples. Preview Features: - Additional actions on reset of graphs, and extraction of individual nodes from a graph (TBB_PREVIEW_FLOW_GRAPH_FEATURES). - Support for an arbitrary number of arguments in parallel_invoke (TBB_PREVIEW_VARIADIC_PARALLEL_INVOKE). Changes affecting backward compatibility: - For compatibility with C++11 standard, copy and move constructors and assignment operators are disabled for all mutex classes. To allow the old behavior, use TBB_DEPRECATED_MUTEX_COPYING macro. - flow::sequencer_node rejects messages with repeating sequence numbers. - Changed internal interface between tbbmalloc and tbbmalloc_proxy. - Following deprecated functionality has been removed: old debugging macros TBB_DO_ASSERT & TBB_DO_THREADING_TOOLS; no-op depth-related methods in class task; tbb::deprecated::concurrent_queue; deprecated variants of concurrent_vector methods. - register_successor() and remove_successor() are deprecated as methods to add and remove edges in flow::graph; use make_edge() and remove_edge() instead. Bugs fixed: - Fixed incorrect scalable_msize() implementation for aligned objects. - Flow graph buffering nodes now destroy their copy of forwarded items. - Multiple fixes in task_arena implementation, including for: inconsistent task scheduler state inside executed functions; incorrect floating-point settings and exception propagation; possible stalls in concurrent invocations of execute(). - Fixed floating-point settings propagation when the same instance of task_group_context is used in different arenas. - Fixed compilation error in pipeline.h with Intel Compiler on OS X*. - Added missed headers for individual components to tbb.h. Open-source contributions integrated: - Range interface addition to parallel_do, parallel_for_each and parallel_sort by Stephan Dollberg. - Variadic template implementation of parallel_invoke by Kizza George Mbidde (see Preview Features). - Improvement in Seismic example for MacBook Pro* with Retina* display by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.2 Update 5 TBB_INTERFACE_VERSION == 7005 Changes (w.r.t. Intel TBB 4.2 Update 4): - The second template argument of class aligned_space now is set to 1 by default. Preview Features: - Better support for exception safety, task priorities and floating point settings in class task_arena. - task_arena::current_slot() has been renamed to task_arena::current_thread_index(). Bugs fixed: - Task priority change possibly ignored by a worker thread entering a nested parallel construct. - Memory leaks inside the task scheduler when running on Intel(R) Xeon Phi(tm) coprocessor. Open-source contributions integrated: - Improved detection of X Window support for Intel TBB examples and other feedback by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.2 Update 4 TBB_INTERFACE_VERSION == 7004 Changes (w.r.t. Intel TBB 4.2 Update 3): - Added possibility to specify floating-point settings at invocation of most parallel algorithms (including flow::graph) via task_group_context. - Added dynamic replacement of malloc_usable_size() under Linux*/Android* and dlmalloc_usable_size() under Android*. - Added new methods to concurrent_vector: grow_by() that appends a sequence between two given iterators; grow_to_at_least() that initializes new elements with a given value. - Improved affinity_partitioner for better performance on balanced workloads. - Improvements in the task scheduler, including better scalability when threads search for a task arena, and better diagnostics. - Improved allocation performance for workloads that do intensive allocation/releasing of same-size objects larger than ~8KB from multiple threads. - Exception support is enabled by default for 32-bit MinGW compilers. - The tachyon example for Android* can be built for all targets supported by the installed NDK. - Added Windows Store* version of the tachyon example. - GettingStarted/sub_string_finder example ported to offload execution on Windows* for Intel(R) Many Integrated Core Architecture. Preview Features: - Removed task_scheduler_observer::on_scheduler_leaving() callback. - Added task_scheduler_observer::may_sleep() callback. - The CPF or_node has been renamed indexer_node. The input to indexer_node is now a list of types. The output of indexer_node is a tagged_msg type composed of a tag and a value. For indexer_node, the tag is a size_t. Bugs fixed: - Fixed data races in preview extensions of task_scheduler_observer. - Added noexcept(false) for destructor of task_group_base to avoid crash on cancellation of structured task group in C++11. Open-source contributions integrated: - Improved concurrency detection for BG/Q, and other improvements by Raf Schietekat. - Fix for crashes in enumerable_thread_specific in case if a contained object is too big to be constructed on the stack by Adrien Guinet. ------------------------------------------------------------------------ Intel TBB 4.2 Update 3 TBB_INTERFACE_VERSION == 7003 Changes (w.r.t. Intel TBB 4.2 Update 2): - Added support for Microsoft* Visual Studio* 2013. - Improved Microsoft* PPL-compatible form of parallel_for for better support of auto-vectorization. - Added a new example for cancellation and reset in the flow graph: Kohonen self-organizing map (examples/graph/som). - Various improvements in source code, tests, and makefiles. Bugs fixed: - Added dynamic replacement of _aligned_msize() previously missed. - Fixed task_group::run_and_wait() to throw invalid_multiple_scheduling exception if the specified task handle is already scheduled. Open-source contributions integrated: - A fix for ARM* processors by Steve Capper. - Improvements in std::swap calls by Robert Maynard. ------------------------------------------------------------------------ Intel TBB 4.2 Update 2 TBB_INTERFACE_VERSION == 7002 Changes (w.r.t. Intel TBB 4.2 Update 1): - Enable C++11 features for Microsoft* Visual Studio* 2013 Preview. - Added a test for compatibility of TBB containers with C++11 range-based for loop. Changes affecting backward compatibility: - Internal layout changed for class tbb::flow::limiter_node. Preview Features: - Added speculative_spin_rw_mutex, a read-write lock class which uses Intel(R) Transactional Synchronization Extensions. Bugs fixed: - When building for Intel(R) Xeon Phi(tm) coprocessor, TBB programs no longer require explicit linking with librt and libpthread. Open-source contributions integrated: - Fixes for ARM* processors by Steve Capper, Leif Lindholm and Steven Noonan. - Support for Clang on Linux by Raf Schietekat. - Typo correction in scheduler.cpp by Julien Schueller. ------------------------------------------------------------------------ Intel TBB 4.2 Update 1 TBB_INTERFACE_VERSION == 7001 Changes (w.r.t. Intel TBB 4.2): - Added project files for Microsoft* Visual Studio* 2010. - Initial support of Microsoft* Visual Studio* 2013 Preview. - Enable C++11 features available in Intel(R) C++ Compiler 14.0. - scalable_allocation_mode(TBBMALLOC_SET_SOFT_HEAP_LIMIT, ) can be used to urge releasing memory from tbbmalloc internal buffers when the given limit is exceeded. Preview Features: - Class task_arena no longer requires linking with a preview library, though still remains a community preview feature. - The method task_arena::wait_until_empty() is removed. - The method task_arena::current_slot() now returns -1 if the task scheduler is not initialized in the thread. Changes affecting backward compatibility: - Because of changes in internal layout of graph nodes, the namespace interface number of flow::graph has been incremented from 6 to 7. Bugs fixed: - Fixed a race in lazy initialization of task_arena. - Fixed flow::graph::reset() to prevent situations where tasks would be spawned in the process of resetting the graph to its initial state. - Fixed decrement bug in limiter_node. - Fixed a race in arc deletion in the flow graph. Open-source contributions integrated: - Improved support for IBM* Blue Gene* by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.2 TBB_INTERFACE_VERSION == 7000 Changes (w.r.t. Intel TBB 4.1 Update 4): - Added speculative_spin_mutex, which uses Intel(R) Transactional Synchronization Extensions when they are supported by hardware. - Binary files linked with libc++ (the C++ standard library in Clang) were added on OS X*. - For OS X* exact exception propagation is supported with Clang; it requires use of libc++ and corresponding Intel TBB binaries. - Support for C++11 initializer lists in constructor and assignment has been added to concurrent_hash_map, concurrent_unordered_set, concurrent_unordered_multiset, concurrent_unordered_map, concurrent_unordered_multimap. - The memory allocator may now clean its per-thread memory caches when it cannot get more memory. - Added the scalable_allocation_command() function for on-demand cleaning of internal memory caches. - Reduced the time overhead for freeing memory objects smaller than ~8K. - Simplified linking with the debug library for applications that use Intel TBB in code offloaded to Intel(R) Xeon Phi(tm) coprocessors. See an example in examples/GettingStarted/sub_string_finder/Makefile. - Various improvements in source code, scripts and makefiles. Changes affecting backward compatibility: - tbb::flow::graph has been modified to spawn its tasks; the old behaviour (task enqueuing) is deprecated. This change may impact applications that expected a flow graph to make progress without calling wait_for_all(), which is no longer guaranteed. See the documentation for more details. - Changed the return values of the scalable_allocation_mode() function. Bugs fixed: - Fixed a leak of parallel_reduce body objects when execution is cancelled or an exception is thrown, as suggested by Darcy Harrison. - Fixed a race in the task scheduler which can lower the effective priority despite the existence of higher priority tasks. - On Linux an error during destruction of the internal thread local storage no longer results in an exception. Open-source contributions integrated: - Fixed task_group_context state propagation to unrelated context trees by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.1 Update 4 TBB_INTERFACE_VERSION == 6105 Changes (w.r.t. Intel TBB 4.1 Update 3): - Use /volatile:iso option with VS 2012 to disable extended semantics for volatile variables. - Various improvements in affinity_partitioner, scheduler, tests, examples, makefiles. - Concurrent_priority_queue class now supports initialization/assignment via C++11 initializer list feature (std::initializer_list). Bugs fixed: - Fixed more possible stalls in concurrent invocations of task_arena::execute(), especially waiting for enqueued tasks. - Fixed requested number of workers for task_arena(P,0). - Fixed interoperability with Intel(R) VTune(TM) Amplifier XE in case of using task_arena::enqueue() from a terminating thread. Open-source contributions integrated: - Type fixes, cleanups, and code beautification by Raf Schietekat. - Improvements in atomic operations for big endian platforms by Raf Schietekat. ------------------------------------------------------------------------ Intel TBB 4.1 Update 3 TBB_INTERFACE_VERSION == 6103 Changes (w.r.t. Intel TBB 4.1 Update 2): - Binary files for Android* applications were added to the Linux* OS package. - Binary files for Windows Store* applications were added to the Windows* OS package. - Exact exception propagation (exception_ptr) support on Linux OS is now turned on by default for GCC 4.4 and higher. - Stopped implicit use of large memory pages by tbbmalloc (Linux-only). Now use of large pages must be explicitly enabled with scalable_allocation_mode() function or TBB_MALLOC_USE_HUGE_PAGES environment variable. Community Preview Features: - Extended class task_arena constructor and method initialize() to allow some concurrency to be reserved strictly for application threads. - New methods terminate() and is_active() were added to class task_arena. Bugs fixed: - Fixed initialization of hashing helper constant in the hash containers. - Fixed possible stalls in concurrent invocations of task_arena::execute() when no worker thread is available to make progress. - Fixed incorrect calculation of hardware concurrency in the presence of inactive processor groups, particularly on systems running Windows* 8 and Windows* Server 2012. Open-source contributions integrated: - The fix for the GUI examples on OS X* systems by Raf Schietekat. - Moved some power-of-2 calculations to functions to improve readability by Raf Schietekat. - C++11/Clang support improvements by arcata. - ARM* platform isolation layer by Steve Capper, Leif Lindholm, Leo Lara (ARM). ------------------------------------------------------------------------ Intel TBB 4.1 Update 2 TBB_INTERFACE_VERSION == 6102 Changes (w.r.t. Intel TBB 4.1 Update 1): - Objects up to 128 MB are now cached by the tbbmalloc. Previously the threshold was 8MB. Objects larger than 128 MB are still processed by direct OS calls. - concurrent_unordered_multiset and concurrent_unordered_multimap have been added, based on Microsoft* PPL prototype. - Ability to value-initialize a tbb::atomic variable on construction in C++11, with const expressions properly supported. Community Preview Features: - Added a possibility to wait until all worker threads terminate. This is necessary before calling fork() from an application. Bugs fixed: - Fixed data race in tbbmalloc that might lead to memory leaks for large object allocations. - Fixed task_arena::enqueue() to use task_group_context of target arena. - Improved implementation of 64 bit atomics on ia32. ------------------------------------------------------------------------ Intel TBB 4.1 Update 1 TBB_INTERFACE_VERSION == 6101 Changes (w.r.t. Intel TBB 4.1): - concurrent_vector class now supports initialization/assignment via C++11 initializer list feature (std::initializer_list) - Added implementation of the platform isolation layer based on Intel compiler atomic built-ins; it is supposed to work on any platform supported by compiler version 12.1 and newer. - Using GetNativeSystemInfo() instead of GetSystemInfo() to support more than 32 processors for 32-bit applications under WOW64. - The following form of parallel_for: parallel_for(first, last, [step,] f[, context]) now accepts an optional partitioner parameter after the function f. Backward-incompatible API changes: - The library no longer injects tuple in to namespace std. In previous releases, tuple was injected into namespace std by flow_graph.h when std::tuple was not available. In this release, flow_graph.h now uses tbb::flow::tuple. On platforms where std::tuple is available, tbb::flow::tuple is typedef'ed to std::tuple. On all other platforms, tbb::flow::tuple provides a subset of the functionality defined by std::tuple. Users of flow_graph.h may need to change their uses of std::tuple to tbb::flow::tuple to ensure compatibility with non-C++11 compliant compilers. Bugs fixed: - Fixed local observer to be able to override propagated CPU state and to provide correct value of task_arena::current_slot() in callbacks. ------------------------------------------------------------------------ Intel TBB 4.1 TBB_INTERFACE_VERSION == 6100 Changes (w.r.t. Intel TBB 4.0 Update 5): - _WIN32_WINNT must be set to 0x0501 or greater in order to use TBB on Microsoft* Windows*. - parallel_deterministic_reduce template function is fully supported. - TBB headers can be used with C++0x/C++11 mode (-std=c++0x) of GCC and Intel(R) Compiler. - C++11 std::make_exception_ptr is used where available, instead of std::copy_exception from earlier C++0x implementations. - Improvements in the TBB allocator to reduce extra memory consumption. - Partial refactoring of the task scheduler data structures. - TBB examples allow more flexible specification of the thread number, including arithmetic and geometric progression. Bugs fixed: - On Linux & OS X*, pre-built TBB binaries do not yet support exact exception propagation via C++11 exception_ptr. To prevent run time errors, by default TBB headers disable exact exception propagation even if the C++ implementation provides exception_ptr. Community Preview Features: - Added: class task_arena, for work submission by multiple application threads with thread-independent control of concurrency level. - Added: task_scheduler_observer can be created as local to a master thread, to observe threads that work on behalf of that master. Local observers may have new on_scheduler_leaving() callback. ------------------------------------------------------------------------ Intel TBB 4.0 Update 5 TBB_INTERFACE_VERSION == 6005 Changes (w.r.t. Intel TBB 4.0 Update 4): - Parallel pipeline optimization (directly storing small objects in the interstage data buffers) limited to trivially-copyable types for C++11 and a short list of types for earlier compilers. - _VARIADIC_MAX switch is honored for TBB tuple implementation and flow::graph nodes based on tuple. - Support of Cocoa framework was added to the GUI examples on OS X* systems. Bugs fixed: - Fixed a tv_nsec overflow bug in condition_variable::wait_for. - Fixed execution order of enqueued tasks with different priorities. - Fixed a bug with task priority changes causing lack of progress for fire-and-forget tasks when TBB was initialized to use 1 thread. - Fixed duplicate symbol problem when linking multiple compilation units that include flow_graph.h on VC 10. ------------------------------------------------------------------------ Intel TBB 4.0 Update 4 TBB_INTERFACE_VERSION == 6004 Changes (w.r.t. Intel TBB 4.0 Update 3): - The TBB memory allocator transparently supports large pages on Linux. - A new flow_graph example, logic_sim, was added. - Support for DirectX* 9 was added to GUI examples. Community Preview Features: - Added: aggregator, a new concurrency control mechanism. Bugs fixed: - The abort operation on concurrent_bounded_queue now leaves the queue in a reusable state. If a bad_alloc or bad_last_alloc exception is thrown while the queue is recovering from an abort, that exception will be reported instead of user_abort on the thread on which it occurred, and the queue will not be reusable. - Steal limiting heuristic fixed to avoid premature stealing disabling when large amount of __thread data is allocated on thread stack. - Fixed a low-probability leak of arenas in the task scheduler. - In STL-compatible allocator classes, the method construct() was fixed to comply with C++11 requirements. - Fixed a bug that prevented creation of fixed-size memory pools smaller than 2M. - Significantly reduced the amount of warnings from various compilers. Open-source contributions integrated: - Multiple improvements by Raf Schietekat. - Basic support for Clang on OS X* by Blas Rodriguez Somoza. - Fixes for warnings and corner-case bugs by Blas Rodriguez Somoza and Edward Lam. ------------------------------------------------------------------------ Intel TBB 4.0 Update 3 TBB_INTERFACE_VERSION == 6003 Changes (w.r.t. Intel TBB 4.0 Update 2): - Modifications to the low-level API for memory pools: added support for aligned allocations; pool policies reworked to allow backward-compatible extensions; added a policy to not return memory space till destruction; pool_reset() does not return memory space anymore. - Class tbb::flow::graph_iterator added to iterate over all nodes registered with a graph instance. - multioutput_function_node has been renamed multifunction_node. multifunction_node and split_node are now fully-supported features. - For the tagged join node, the policy for try_put of an item with already existing tag has been defined: the item will be rejected. - Matching the behavior on Windows, on other platforms the optional shared libraries (libtbbmalloc, libirml) now are also searched only in the directory where libtbb is located. - The platform isolation layer based on GCC built-ins is extended. Backward-incompatible API changes: - a graph reference parameter is now required to be passed to the constructors of the following flow graph nodes: overwrite_node, write_once_node, broadcast_node, and the CPF or_node. - the following tbb::flow node methods and typedefs have been renamed: Old New join_node and or_node: inputs() -> input_ports() input_ports_tuple_type -> input_ports_type multifunction_node and split_node: ports_type -> output_ports_type Bugs fixed: - Not all logical processors were utilized on systems with more than 64 cores split by Windows into several processor groups. ------------------------------------------------------------------------ Intel TBB 4.0 Update 2 commercial-aligned release TBB_INTERFACE_VERSION == 6002 Changes (w.r.t. Intel TBB 4.0 Update 1 commercial-aligned release): - concurrent_bounded_queue now has an abort() operation that releases threads involved in pending push or pop operations. The released threads will receive a tbb::user_abort exception. - Added Community Preview Feature: concurrent_lru_cache container, a concurrent implementation of LRU (least-recently-used) cache. Bugs fixed: - fixed a race condition in the TBB scalable allocator. - concurrent_queue counter wraparound bug was fixed, which occurred when the number of push and pop operations exceeded ~>4 billion on IA32. - fixed races in the TBB scheduler that could put workers asleep too early, especially in presence of affinitized tasks. ------------------------------------------------------------------------ Intel TBB 4.0 Update 1 commercial-aligned release TBB_INTERFACE_VERSION == 6000 (forgotten to increment) Changes (w.r.t. Intel TBB 4.0 commercial-aligned release): - Memory leaks fixed in binpack example. - Improvements and fixes in the TBB allocator. ------------------------------------------------------------------------ Intel TBB 4.0 commercial-aligned release TBB_INTERFACE_VERSION == 6000 Changes (w.r.t. Intel TBB 3.0 Update 8 commercial-aligned release): - concurrent_priority_queue is now a fully supported feature. Capacity control methods were removed. - Flow graph is now a fully supported feature. - A new memory backend has been implemented in the TBB allocator. It can reuse freed memory for both small and large objects, and returns unused memory blocks to the OS more actively. - Improved partitioning algorithms for parallel_for and parallel_reduce to better handle load imbalance. - The convex_hull example has been refactored for reproducible performance results. - The major interface version has changed from 5 to 6. Deprecated interfaces might be removed in future releases. Community Preview Features: - Added: serial subset, i.e. sequential implementations of TBB generic algorithms (currently, only provided for parallel_for). - Preview of new flow graph nodes: or_node (accepts multiple inputs, forwards each input separately to all successors), split_node (accepts tuples, and forwards each element of a tuple to a corresponding successor), and multioutput_function_node (accepts one input, and passes the input and a tuple of output ports to the function body to support outputs to multiple successors). - Added: memory pools for more control on memory source, grouping, and collective deallocation. ------------------------------------------------------------------------ Intel TBB 3.0 Update 8 commercial-aligned release TBB_INTERFACE_VERSION == 5008 Changes (w.r.t. Intel TBB 3.0 Update 7 commercial-aligned release): - Task priorities become an official feature of TBB, not community preview as before. - Atomics API extended, and implementation refactored. - Added task::set_parent() method. - Added concurrent_unordered_set container. Open-source contributions integrated: - PowerPC support by Raf Schietekat. - Fix of potential task pool overrun and other improvements in the task scheduler by Raf Schietekat. - Fix in parallel_for_each to work with std::set in Visual* C++ 2010. Community Preview Features: - Graph community preview feature was renamed to flow graph. Multiple improvements in the implementation. Binpack example was added for the feature. - A number of improvements to concurrent_priority_queue. Shortpath example was added for the feature. - TBB runtime loaded functionality was added (Windows*-only). It allows to specify which versions of TBB should be used, as well as to set directories for the library search. - parallel_deterministic_reduce template function was added. ------------------------------------------------------------------------ Intel TBB 3.0 Update 7 commercial-aligned release TBB_INTERFACE_VERSION == 5006 (forgotten to increment) Changes (w.r.t. Intel TBB 3.0 Update 6 commercial-aligned release): - Added implementation of the platform isolation layer based on GCC atomic built-ins; it is supposed to work on any platform where GCC has these built-ins. Community Preview Features: - Graph's dining_philosophers example added. - A number of improvements to graph and concurrent_priority_queue. To generate a diff of this commit: cvs rdiff -u -r1.8 -r1.9 pkgsrc/parallel/threadingbuildingblocks/Makefile cvs rdiff -u -r1.1.1.1 -r1.2 pkgsrc/parallel/threadingbuildingblocks/PLIST \ pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk cvs rdiff -u -r1.3 -r1.4 pkgsrc/parallel/threadingbuildingblocks/distinfo cvs rdiff -u -r1.1 -r0 \ pkgsrc/parallel/threadingbuildingblocks/patches/patch-build_FreeBSD.gcc.inc Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. --_----------=_1599305648255410 Content-Disposition: inline Content-Length: 8911 Content-Transfer-Encoding: binary Content-Type: text/x-diff; charset=us-ascii Modified files: Index: pkgsrc/parallel/threadingbuildingblocks/Makefile diff -u pkgsrc/parallel/threadingbuildingblocks/Makefile:1.8 pkgsrc/parallel/threadingbuildingblocks/Makefile:1.9 --- pkgsrc/parallel/threadingbuildingblocks/Makefile:1.8 Mon Jan 1 18:16:38 2018 +++ pkgsrc/parallel/threadingbuildingblocks/Makefile Sat Sep 5 11:34:07 2020 @@ -1,33 +1,33 @@ -# $NetBSD: Makefile,v 1.8 2018/01/01 18:16:38 rillig Exp $ +# $NetBSD: Makefile,v 1.9 2020/09/05 11:34:07 ryoon Exp $ -DISTNAME= tbb30_20110325oss_src -PKGNAME= threadingbuildingblocks-3.0.6 # for "3.0 update 6" +DISTNAME= oneTBB-2020.3 +PKGNAME= ${DISTNAME:S/oneTBB-/threadingbuildingblocks-/} CATEGORIES= parallel -MASTER_SITES= http://threadingbuildingblocks.org/uploads/76/168/3.0%20update%206/ -EXTRACT_SUFX= .tgz +MASTER_SITES= ${MASTER_SITE_GITHUB:=oneapi-src/} +EXTRACT_SUFX= .tar.gz +GITHUB_PROJECT= oneTBB +GITHUB_TAG= v${PKGVERSION_NOREV} MAINTAINER= asau@inbox.ru HOMEPAGE= https://www.threadingbuildingblocks.org/ COMMENT= Threading Buildling Blocks -WRKSRC= ${WRKDIR}/${DISTNAME:_src=} #tbb30_20101215oss - USE_LANGUAGES= c c++ USE_TOOLS= gmake pax MAKE_FLAGS= tbb_build_prefix=build # use fixed path +MAKE_FLAGS+= native_compiler=${CC_VERSION:C/-[[:digit:]].*//} +MAKE_FLAGS+= compiler=${CC_VERSION:C/-[[:digit:]].*//} BUILD_TARGET= default TEST_TARGET= test pre-configure: cd ${WRKSRC}/build/ && cp FreeBSD.gcc.inc NetBSD.gcc.inc && cp FreeBSD.inc NetBSD.inc -INSTALLATION_DIRS= include lib share/doc/${PKGBASE} +INSTALLATION_DIRS= include lib do-install: ${INSTALL_LIB} ${WRKSRC}/build/build_release/libtbb.so ${DESTDIR}${PREFIX}/lib/ ${INSTALL_LIB} ${WRKSRC}/build/build_release/libtbbmalloc.so ${DESTDIR}${PREFIX}/lib/ - ${INSTALL_LIB} ${WRKSRC}/build/build_debug/libtbb_debug.so ${DESTDIR}${PREFIX}/lib/ - ${INSTALL_LIB} ${WRKSRC}/build/build_debug/libtbbmalloc_debug.so ${DESTDIR}${PREFIX}/lib/ (cd ${WRKSRC}/include && pax -rw tbb ${DESTDIR}${PREFIX}/include/) # documentation: # (cd $(WRKSRC)/doc/html && pax -rw . $(DESTDIR)$(PREFIX)/share/doc/html/$(PKGBASE)/) Index: pkgsrc/parallel/threadingbuildingblocks/PLIST diff -u pkgsrc/parallel/threadingbuildingblocks/PLIST:1.1.1.1 pkgsrc/parallel/threadingbuildingblocks/PLIST:1.2 --- pkgsrc/parallel/threadingbuildingblocks/PLIST:1.1.1.1 Sat Aug 27 19:48:13 2011 +++ pkgsrc/parallel/threadingbuildingblocks/PLIST Sat Sep 5 11:34:07 2020 @@ -1,14 +1,11 @@ -@comment $NetBSD: PLIST,v 1.1.1.1 2011/08/27 19:48:13 asau Exp $ -include/tbb/_aggregator_internal.h -include/tbb/_concurrent_queue_internal.h -include/tbb/_concurrent_unordered_internal.h -include/tbb/_item_buffer.h -include/tbb/_tbb_windef.h +@comment $NetBSD: PLIST,v 1.2 2020/09/05 11:34:07 ryoon Exp $ +include/tbb/aggregator.h include/tbb/aligned_space.h include/tbb/atomic.h include/tbb/blocked_range.h include/tbb/blocked_range2d.h include/tbb/blocked_range3d.h +include/tbb/blocked_rangeNd.h include/tbb/cache_aligned_allocator.h include/tbb/combinable.h include/tbb/compat/condition_variable @@ -16,27 +13,75 @@ include/tbb/compat/ppl.h include/tbb/compat/thread include/tbb/compat/tuple include/tbb/concurrent_hash_map.h +include/tbb/concurrent_lru_cache.h +include/tbb/concurrent_map.h include/tbb/concurrent_priority_queue.h include/tbb/concurrent_queue.h +include/tbb/concurrent_set.h include/tbb/concurrent_unordered_map.h +include/tbb/concurrent_unordered_set.h include/tbb/concurrent_vector.h include/tbb/critical_section.h include/tbb/enumerable_thread_specific.h -include/tbb/graph.h +include/tbb/flow_graph.h +include/tbb/flow_graph_abstractions.h +include/tbb/flow_graph_opencl_node.h +include/tbb/global_control.h include/tbb/index.html +include/tbb/info.h +include/tbb/internal/_aggregator_impl.h +include/tbb/internal/_allocator_traits.h +include/tbb/internal/_concurrent_queue_impl.h +include/tbb/internal/_concurrent_skip_list_impl.h +include/tbb/internal/_concurrent_unordered_impl.h +include/tbb/internal/_deprecated_header_message_guard.h +include/tbb/internal/_flow_graph_async_msg_impl.h +include/tbb/internal/_flow_graph_body_impl.h +include/tbb/internal/_flow_graph_cache_impl.h +include/tbb/internal/_flow_graph_impl.h +include/tbb/internal/_flow_graph_indexer_impl.h +include/tbb/internal/_flow_graph_item_buffer_impl.h +include/tbb/internal/_flow_graph_join_impl.h +include/tbb/internal/_flow_graph_node_impl.h +include/tbb/internal/_flow_graph_node_set_impl.h +include/tbb/internal/_flow_graph_nodes_deduction.h +include/tbb/internal/_flow_graph_streaming_node.h +include/tbb/internal/_flow_graph_tagged_buffer_impl.h +include/tbb/internal/_flow_graph_trace_impl.h +include/tbb/internal/_flow_graph_types_impl.h +include/tbb/internal/_mutex_padding.h +include/tbb/internal/_node_handle_impl.h +include/tbb/internal/_range_iterator.h +include/tbb/internal/_tbb_hash_compare_impl.h +include/tbb/internal/_tbb_strings.h +include/tbb/internal/_tbb_trace_impl.h +include/tbb/internal/_tbb_windef.h +include/tbb/internal/_template_helpers.h +include/tbb/internal/_warning_suppress_disable_notice.h +include/tbb/internal/_warning_suppress_enable_notice.h +include/tbb/internal/_x86_eliding_mutex_impl.h +include/tbb/internal/_x86_rtm_rw_mutex_impl.h +include/tbb/iterators.h +include/tbb/machine/gcc_arm.h include/tbb/machine/gcc_generic.h +include/tbb/machine/gcc_ia32_common.h +include/tbb/machine/gcc_itsx.h include/tbb/machine/ibm_aix51.h +include/tbb/machine/icc_generic.h include/tbb/machine/linux_common.h include/tbb/machine/linux_ia32.h include/tbb/machine/linux_ia64.h include/tbb/machine/linux_intel64.h include/tbb/machine/mac_ppc.h include/tbb/machine/macos_common.h +include/tbb/machine/mic_common.h +include/tbb/machine/msvc_armv7.h +include/tbb/machine/msvc_ia32_common.h include/tbb/machine/sunos_sparc.h include/tbb/machine/windows_api.h include/tbb/machine/windows_ia32.h include/tbb/machine/windows_intel64.h -include/tbb/machine/xbox360_ppc.h +include/tbb/memory_pool.h include/tbb/mutex.h include/tbb/null_mutex.h include/tbb/null_rw_mutex.h @@ -59,12 +104,14 @@ include/tbb/scalable_allocator.h include/tbb/spin_mutex.h include/tbb/spin_rw_mutex.h include/tbb/task.h +include/tbb/task_arena.h include/tbb/task_group.h include/tbb/task_scheduler_init.h include/tbb/task_scheduler_observer.h include/tbb/tbb.h include/tbb/tbb_allocator.h include/tbb/tbb_config.h +include/tbb/tbb_disable_exceptions.h include/tbb/tbb_exception.h include/tbb/tbb_machine.h include/tbb/tbb_profiling.h @@ -73,6 +120,4 @@ include/tbb/tbb_thread.h include/tbb/tbbmalloc_proxy.h include/tbb/tick_count.h lib/libtbb.so -lib/libtbb_debug.so lib/libtbbmalloc.so -lib/libtbbmalloc_debug.so Index: pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk diff -u pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk:1.1.1.1 pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk:1.2 --- pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk:1.1.1.1 Sat Aug 27 19:48:13 2011 +++ pkgsrc/parallel/threadingbuildingblocks/buildlink3.mk Sat Sep 5 11:34:07 2020 @@ -1,11 +1,11 @@ -# $NetBSD: buildlink3.mk,v 1.1.1.1 2011/08/27 19:48:13 asau Exp $ +# $NetBSD: buildlink3.mk,v 1.2 2020/09/05 11:34:07 ryoon Exp $ BUILDLINK_TREE+= threadingbuildingblocks .if !defined(THREADINGBUILDINGBLOCKS_BUILDLINK3_MK) THREADINGBUILDINGBLOCKS_BUILDLINK3_MK:= -BUILDLINK_API_DEPENDS.threadingbuildingblocks+= threadingbuildingblocks>=3.0.6 +BUILDLINK_API_DEPENDS.threadingbuildingblocks+= threadingbuildingblocks>=2020.3 BUILDLINK_PKGSRCDIR.threadingbuildingblocks?= ../../parallel/threadingbuildingblocks .endif # THREADINGBUILDINGBLOCKS_BUILDLINK3_MK Index: pkgsrc/parallel/threadingbuildingblocks/distinfo diff -u pkgsrc/parallel/threadingbuildingblocks/distinfo:1.3 pkgsrc/parallel/threadingbuildingblocks/distinfo:1.4 --- pkgsrc/parallel/threadingbuildingblocks/distinfo:1.3 Mon Nov 2 23:46:13 2015 +++ pkgsrc/parallel/threadingbuildingblocks/distinfo Sat Sep 5 11:34:07 2020 @@ -1,7 +1,6 @@ -$NetBSD: distinfo,v 1.3 2015/11/02 23:46:13 agc Exp $ +$NetBSD: distinfo,v 1.4 2020/09/05 11:34:07 ryoon Exp $ -SHA1 (tbb30_20110325oss_src.tgz) = b58650cdaa8e8497de2a797af1d03dcfc1c63351 -RMD160 (tbb30_20110325oss_src.tgz) = c95aa788d518d806b516b9e9e179d93bce19aa9c -SHA512 (tbb30_20110325oss_src.tgz) = 56498482bdcbe87f0a4d59234de0ba888b1e0770aff28dbe6e5b6c169e8c0b1987480db6cf4d1aab5c3da97ca5da626469237643df44762ba76121d4d93629b9 -Size (tbb30_20110325oss_src.tgz) = 1880565 bytes -SHA1 (patch-build_FreeBSD.gcc.inc) = f3f0e418b1eda91646e9e9cc9c34d40865eb7514 +SHA1 (oneTBB-2020.3.tar.gz) = ae543670251a6d667e6f077ecfab0d5bb09b270c +RMD160 (oneTBB-2020.3.tar.gz) = 1f3918c0dadfcddd2b38f398299de0d8542f11b4 +SHA512 (oneTBB-2020.3.tar.gz) = ea1ffd22c7234d715b8c46a4e51b40719c7a9b8837ab3166f1da5a2c6061167c2be2126b1d74fd361eec6975b8fce0df26829ca2e7af8029edbb52e40f23d630 +Size (oneTBB-2020.3.tar.gz) = 2639737 bytes --_----------=_1599305648255410--