HPX 1.1.0

The STE||AR Group

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

Table of Contents

What's New
HPX V1.1.0 (Mar 24, 2018)
Previous HPX Releases
HPX V1.0 (Apr 24, 2017)
HPX V0.9.99 (Jul 15, 2016)
HPX V0.9.11 (Nov 11, 2015)
HPX V0.9.10 (Mar 24, 2015)
HPX V0.9.9 (Oct 31, 2014, codename Spooky)
HPX V0.9.8 (Mar 24, 2014)
HPX V0.9.7 (Nov 13, 2013)
HPX V0.9.6 (Jul 30, 2013)
HPX V0.9.5 (Jan 16, 2013)
HPX V0.9.0 (Jul 5, 2012)
HPX V0.8.1 (Apr 21, 2012)
HPX V0.8.0 (Mar 23, 2012)
HPX V0.7.0 (Dec 12, 2011)
Getting Started
How to Use HPX Applications with PBS
How to Use HPX Applications with SLURM
What makes our Systems Slow?
Technology Demands New Response
Governing Principles applied while Developing HPX
Hello World
Interest Calculator
Futurization Example
The HPX Build System
CMake Basics
Build Prerequisites
Installing Boost Libraries
Installing Hwloc
Building HPX
CMake Variables used to configure HPX
CMake Toolchains shipped with HPX
Build recipes
Setting up the HPX Documentation Tool Chain
Building Projects using HPX
Using HPX with pkg-config
Using HPX with CMake based projects
Testing HPX
Running tests manually
Issue Tracker
Launching HPX
Configure HPX Applications
The HPX INI File Format
Built-in Default Configuration Settings
Loading INI Files
Loading Components
HPX Command Line Options
More Details about HPX Command Line Options
Utilities in HPX
HPX System Components
The HPX I/O-streams Component
Writing HPX applications
Global Names
Applying Actions
Action Type Definition
Action Invocation
Applying an Action Asynchronously without any Synchronization
Applying an Action Asynchronously with Synchronization
Applying an Action Synchronously
Applying an Action with a Continuation but without any Synchronization
Applying an Action with a Continuation and with Synchronization
Action Error Handling
Writing Components
Defining Components
Defining Client Side Representation Classes
Creating Component Instances
Using Component Instances
Using LCOs
Extended Facilities for Futures
High Level Parallel Facilities
Using Parallel Algorithms
Executors and Executor Traits
Executor Parameters and Executor Parameter Traits
Using Task Blocks
Extensions for Task Blocks
Error Handling
Performance Counters
Performance Counter Names
Consuming Performance Counter Data
Consuming Performance Counter Data from the Command Line
Consuming Performance Counter Data using the HPX API
Providing Performance Counter Data
Exposing Performance Counter Data using a Simple Function
Implementing a Full Performance Counter
Existing HPX Performance Counters
HPX Thread Scheduling Policies
Segmented Containers
Using Segmented Containers
Segmented and Segmented Iterator Traits
Using Views
Preface : Why SPMD ?
SPMD Multidimensional Views
C++ Co-Arrays
Preface : Co-array, a segmented container tied to a SPMD Multidimensional View
Using Co-Arrays
Header <hpx/components/component_storage/migrate_from_storage.hpp>
Function template migrate_from_storage
Header <hpx/components/component_storage/migrate_to_storage.hpp>
Function template migrate_to_storage
Function template migrate_to_storage
Header <hpx/error.hpp>
Type error — Possible error conditions.
Header <hpx/error_code.hpp>
Class error_code — A hpx::error_code represents an arbitrary error condition.
Header <hpx/exception.hpp>
Class exception — A hpx::exception is the main exception type used by HPX to report errors.
Struct thread_interrupted — A hpx::thread_interrupted is the exception type used by HPX to interrupt a running HPX thread.
Function diagnostic_information — Extract the diagnostic information embedded in the given exception and return a string holding a formatted message.
Function get_error_what — Return the error message of the thrown exception.
Function get_error_locality_id — Return the locality id where the exception was thrown.
Function get_error — Return the locality id where the exception was thrown.
Function get_error — Return the locality id where the exception was thrown.
Function get_error_host_name — Return the hostname of the locality where the exception was thrown.
Function get_error_process_id — Return the (operating system) process id of the locality where the exception was thrown.
Function get_error_env — Return the environment of the OS-process at the point the exception was thrown.
Function get_error_function_name — Return the function name from which the exception was thrown.
Function get_error_backtrace — Return the stack backtrace from the point the exception was thrown.
Function get_error_file_name — Return the (source code) file name of the function from which the exception was thrown.
Function get_error_line_number — Return the line number in the (source code) file of the function from which the exception was thrown.
Function get_error_os_thread — Return the sequence number of the OS-thread used to execute HPX-threads from which the exception was thrown.
Function get_error_thread_id — Return the unique thread id of the HPX-thread from which the exception was thrown.
Function get_error_thread_description — Return any additionally available thread description of the HPX-thread from which the exception was thrown.
Function get_error_config — Return the HPX configuration information point from which the exception was thrown.
Function get_error_state — Return the HPX runtime state information at which the exception was thrown.
Header <hpx/exception_fwd.hpp>
Global throws — Predefined error_code object used as "throw on error" tag.
Header <hpx/exception_list.hpp>
Class exception_list
Header <hpx/hpx_finalize.hpp>
Function finalize — Main function to gracefully terminate the HPX runtime system.
Function finalize — Main function to gracefully terminate the HPX runtime system.
Function terminate — Terminate any application non-gracefully.
Function disconnect — Disconnect this locality from the application.
Function disconnect — Disconnect this locality from the application.
Function stop — Stop the runtime system.
Header <hpx/hpx_init.hpp>
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Function init — Main entry point for launching the HPX runtime system.
Header <hpx/hpx_start.hpp>
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Function start — Main non-blocking entry point for launching the HPX runtime system.
Header <hpx/hpx_suspend.hpp>
Function suspend — Suspend the runtime system.
Function resume — Resume the HPX runtime system.
Header <hpx/lcos/barrier.hpp>
Class barrier
Header <hpx/lcos/broadcast.hpp>
Function template broadcast — Perform a distributed broadcast operation.
Function template broadcast_apply — Perform an asynchronous (fire&forget) distributed broadcast operation.
Function template broadcast_with_index — Perform a distributed broadcast operation.
Function template broadcast_apply_with_index — Perform an asynchronous (fire&forget) distributed broadcast operation.
Header <hpx/lcos/fold.hpp>
Function template fold — Perform a distributed fold operation.
Function template fold_with_index — Perform a distributed folding operation.
Function template inverse_fold — Perform a distributed inverse folding operation.
Function template inverse_fold_with_index — Perform a distributed inverse folding operation.
Header <hpx/lcos/gather.hpp>
Function template gather_here
Function template gather_there
Function template gather_here
Function template gather_there
Macro HPX_REGISTER_GATHER_DECLARATION — Declare a gather object named name for a given data type type.
Macro HPX_REGISTER_GATHER — Define a gather object named name for a given data type type.
Header <hpx/lcos/split_future.hpp>
Function template split_future
Function template split_future
Header <hpx/lcos/wait_all.hpp>
Function template wait_all
Function template wait_all
Function template wait_all
Function template wait_all
Function template wait_all_n
Header <hpx/lcos/wait_any.hpp>
Function template wait_any
Function template wait_any
Function template wait_any
Function template wait_any
Function template wait_any
Function template wait_any_n
Header <hpx/lcos/wait_each.hpp>
Function template wait_each
Function template wait_each
Function template wait_each
Function template wait_each_n
Header <hpx/lcos/wait_some.hpp>
Function template wait_some
Function template wait_some
Function template wait_some
Function template wait_some
Function template wait_some_n
Header <hpx/lcos/when_all.hpp>
Function template when_all
Function template when_all
Function template when_all
Function template when_all_n
Header <hpx/lcos/when_any.hpp>
Struct template when_any_result
Function template when_any
Function template when_any
Function template when_any
Function template when_any_n
Header <hpx/lcos/when_each.hpp>
Function template when_each
Function template when_each
Function template when_each
Function template when_each_n
Header <hpx/lcos/when_some.hpp>
Struct template when_some_result
Function template when_some
Function template when_some
Function template when_some
Function template when_some
Function template when_some_n
Header <hpx/parallel/algorithms/adjacent_difference.hpp>
Function template adjacent_difference
Function template adjacent_difference
Header <hpx/parallel/algorithms/adjacent_find.hpp>
Function template adjacent_find
Header <hpx/parallel/algorithms/all_any_none.hpp>
Function template none_of
Function template any_of
Function template all_of
Header <hpx/parallel/container_algorithms/all_any_none.hpp>
Function template none_of
Function template any_of
Function template all_of
Header <hpx/parallel/algorithms/copy.hpp>
Function template copy
Function template copy_n
Function template copy_if
Header <hpx/parallel/container_algorithms/copy.hpp>
Function template copy
Function template copy_if
Header <hpx/parallel/algorithms/count.hpp>
Function template count
Function template count_if
Header <hpx/parallel/container_algorithms/count.hpp>
Function template count
Function template count_if
Header <hpx/parallel/algorithms/destroy.hpp>
Function template destroy
Function template destroy_n
Header <hpx/parallel/algorithms/equal.hpp>
Function template equal
Function template equal
Header <hpx/parallel/algorithms/exclusive_scan.hpp>
Function template exclusive_scan
Function template exclusive_scan
Header <hpx/parallel/algorithms/fill.hpp>
Function template fill
Function template fill_n
Header <hpx/parallel/container_algorithms/fill.hpp>
Function template fill
Function template fill_n
Header <hpx/parallel/algorithms/find.hpp>
Function template find
Function template find_if
Function template find_if_not
Function template find_end
Function template find_first_of
Header <hpx/parallel/algorithms/for_each.hpp>
Global F
Function template for_each_n
Header <hpx/parallel/container_algorithms/for_each.hpp>
Function template for_each
Header <hpx/parallel/algorithms/for_loop.hpp>
Function template for_loop
Function template for_loop
Function template for_loop_strided
Function template for_loop_strided
Function template for_loop_n
Function template for_loop_n
Function template for_loop_n_strided
Function template for_loop_n_strided
Header <hpx/parallel/algorithms/for_loop_induction.hpp>
Function template induction
Header <hpx/parallel/algorithms/for_loop_reduction.hpp>
Function template reduction
Header <hpx/parallel/algorithms/generate.hpp>
Function template generate
Function template generate_n
Header <hpx/parallel/container_algorithms/generate.hpp>
Function template generate
Header <hpx/parallel/algorithms/includes.hpp>
Function template includes
Header <hpx/parallel/algorithms/inclusive_scan.hpp>
Function template inclusive_scan
Function template inclusive_scan
Function template inclusive_scan
Header <hpx/parallel/algorithms/is_heap.hpp>
Function template is_heap
Function template is_heap_until
Header <hpx/parallel/container_algorithms/is_heap.hpp>
Function template is_heap
Function template is_heap_until
Header <hpx/parallel/algorithms/is_partitioned.hpp>
Function template is_partitioned
Header <hpx/parallel/algorithms/is_sorted.hpp>
Function template is_sorted
Function template is_sorted_until
Header <hpx/parallel/algorithms/lexicographical_compare.hpp>
Function template lexicographical_compare
Header <hpx/parallel/algorithms/merge.hpp>
Function template merge
Function template inplace_merge
Header <hpx/parallel/container_algorithms/merge.hpp>
Function template merge
Function template inplace_merge
Header <hpx/parallel/algorithms/minmax.hpp>
Function template min_element
Function template max_element
Function template minmax_element
Header <hpx/parallel/container_algorithms/minmax.hpp>
Function template min_element
Function template max_element
Function template minmax_element
Header <hpx/parallel/algorithms/mismatch.hpp>
Function template mismatch
Function template mismatch
Header <hpx/parallel/algorithms/move.hpp>
Function template move
Header <hpx/parallel/algorithms/partition.hpp>
Function template stable_partition
Function template partition
Function template partition_copy
Header <hpx/parallel/container_algorithms/partition.hpp>
Function template partition
Function template partition_copy
Header <hpx/parallel/algorithms/reduce.hpp>
Function template reduce
Function template reduce
Function template reduce
Header <hpx/lcos/reduce.hpp>
Function template reduce — Perform a distributed reduction operation.
Function template reduce_with_index — Perform a distributed reduction operation.
Header <hpx/parallel/algorithms/reduce_by_key.hpp>
Function template reduce_by_key
Header <hpx/parallel/algorithms/remove.hpp>
Function template remove_if
Function template remove
Header <hpx/parallel/container_algorithms/remove.hpp>
Function template remove
Function template remove_if
Header <hpx/parallel/algorithms/remove_copy.hpp>
Function template remove_copy
Function template remove_copy_if
Header <hpx/parallel/container_algorithms/remove_copy.hpp>
Function template remove_copy
Function template remove_copy_if
Header <hpx/parallel/algorithms/replace.hpp>
Function template replace
Function template replace_if
Function template replace_copy
Function template replace_copy_if
Header <hpx/parallel/container_algorithms/replace.hpp>
Function template replace
Function template replace_if
Function template replace_copy
Function template replace_copy_if
Header <hpx/parallel/algorithms/reverse.hpp>
Function template reverse
Function template reverse_copy
Header <hpx/parallel/container_algorithms/reverse.hpp>
Function template reverse
Function template reverse_copy
Header <hpx/parallel/algorithms/rotate.hpp>
Function template rotate
Function template rotate_copy
Header <hpx/parallel/container_algorithms/rotate.hpp>
Function template rotate
Function template rotate_copy
Header <hpx/parallel/algorithms/search.hpp>
Function template search
Function template search_n
Header <hpx/parallel/container_algorithms/search.hpp>
Function template search
Function template search_n
Header <hpx/parallel/algorithms/set_difference.hpp>
Function template set_difference
Header <hpx/parallel/algorithms/set_intersection.hpp>
Function template set_intersection
Header <hpx/parallel/algorithms/set_symmetric_difference.hpp>
Function template set_symmetric_difference
Header <hpx/parallel/algorithms/set_union.hpp>
Function template set_union
Header <hpx/parallel/algorithms/sort.hpp>
Function template sort
Header <hpx/parallel/container_algorithms/sort.hpp>
Function template sort
Header <hpx/parallel/algorithms/sort_by_key.hpp>
Function template sort_by_key
Header <hpx/parallel/algorithms/swap_ranges.hpp>
Function template swap_ranges
Header <hpx/parallel/algorithms/transform.hpp>
Function template transform
Function template transform
Function template transform
Header <hpx/parallel/container_algorithms/transform.hpp>
Function template transform
Function template transform
Function template transform
Header <hpx/parallel/algorithms/transform_exclusive_scan.hpp>
Function template transform_exclusive_scan
Header <hpx/parallel/algorithms/transform_inclusive_scan.hpp>
Function template transform_inclusive_scan
Function template transform_inclusive_scan
Header <hpx/parallel/algorithms/transform_reduce.hpp>
Function template transform_reduce
Header <hpx/parallel/algorithms/transform_reduce_binary.hpp>
Function template transform_reduce
Function template transform_reduce
Header <hpx/parallel/algorithms/uninitialized_copy.hpp>
Function template uninitialized_copy
Function template uninitialized_copy_n
Header <hpx/parallel/algorithms/uninitialized_default_construct.hpp>
Function template uninitialized_default_construct
Function template uninitialized_default_construct_n
Header <hpx/parallel/algorithms/uninitialized_fill.hpp>
Function template uninitialized_fill
Function template uninitialized_fill_n
Header <hpx/parallel/algorithms/uninitialized_move.hpp>
Function template uninitialized_move
Function template uninitialized_move_n
Header <hpx/parallel/algorithms/uninitialized_value_construct.hpp>
Function template uninitialized_value_construct
Function template uninitialized_value_construct_n
Header <hpx/parallel/algorithms/unique.hpp>
Function template unique
Function template unique_copy
Header <hpx/parallel/container_algorithms/unique.hpp>
Function template unique
Function template unique_copy
Header <hpx/parallel/execution_policy.hpp>
Struct parallel_policy
Struct template parallel_policy_shim
Struct parallel_task_policy
Struct template parallel_task_policy_shim
Struct parallel_unsequenced_policy
Struct sequenced_policy
Struct template sequenced_policy_shim
Struct sequenced_task_policy
Struct template sequenced_task_policy_shim
Global task — Default sequential execution policy object.
Global seq — Default sequential execution policy object.
Global par — Default parallel execution policy object.
Global par_unseq — Default vector execution policy object.
Header <hpx/parallel/executors/auto_chunk_size.hpp>
Struct auto_chunk_size
Header <hpx/parallel/executors/dynamic_chunk_size.hpp>
Struct dynamic_chunk_size
Header <hpx/parallel/executors/execution_fwd.hpp>
Struct parallel_execution_tag
Struct sequenced_execution_tag
Struct unsequenced_execution_tag
Header <hpx/parallel/executors/execution_information_fwd.hpp>
Header <hpx/parallel/executors/guided_chunk_size.hpp>
Struct guided_chunk_size
Header <hpx/parallel/executors/parallel_executor.hpp>
Struct template parallel_policy_executor
Header <hpx/parallel/executors/persistent_auto_chunk_size.hpp>
Struct persistent_auto_chunk_size
Header <hpx/parallel/executors/sequenced_executor.hpp>
Struct sequenced_executor
Header <hpx/parallel/executors/service_executors.hpp>
Type definition service_executor
Type definition io_pool_executor
Type definition parcel_pool_executor
Type definition timer_pool_executor
Type definition main_pool_executor
Header <hpx/parallel/executors/static_chunk_size.hpp>
Struct static_chunk_size
Header <hpx/parallel/executors/thread_pool_executors.hpp>
Type definition local_priority_queue_executor
Header <hpx/parallel/task_block.hpp>
Class template task_block
Class task_canceled_exception
Function template define_task_block
Function template define_task_block
Function template define_task_block_restore_thread
Function template define_task_block_restore_thread
Header <hpx/performance_counters/manage_counter_type.hpp>
Function install_counter_type — Install a new generic performance counter type in a way, which will uninstall it automatically during shutdown.
Function install_counter_type
Function install_counter_type — Install a new performance counter type in a way, which will uninstall it automatically during shutdown.
Function install_counter_type — Install a new performance counter type in a way, which will uninstall it automatically during shutdown.
Function install_counter_type — Install a new generic performance counter type in a way, which will uninstall it automatically during shutdown.
Header <hpx/runtime/actions/basic_action.hpp>
Macro HPX_REGISTER_ACTION_DECLARATION — Declare the necessary component action boilerplate code.
Macro HPX_REGISTER_ACTION — Define the necessary component action boilerplate code.
Macro HPX_REGISTER_ACTION_ID — Define the necessary component action boilerplate code and assign a predefined unique id to the action.
Header <hpx/runtime/actions/component_action.hpp>
Macro HPX_DEFINE_COMPONENT_ACTION — Registers a member function of a component as an action type with HPX.
Header <hpx/runtime/actions/plain_action.hpp>
Macro HPX_DEFINE_PLAIN_ACTION — Defines a plain action type.
Macro HPX_DECLARE_PLAIN_ACTION — Declares a plain action type.
Macro HPX_PLAIN_ACTION — Defines a plain action type based on the given function func and registers it with HPX.
Macro HPX_PLAIN_ACTION_ID — Defines a plain action type based on the given function func and registers it with HPX.
Header <hpx/runtime/applier_fwd.hpp>
Function get_applier
Function get_applier_ptr
Header <hpx/runtime/basename_registration_fwd.hpp>
Function find_all_from_basename
Function find_from_basename
Function find_from_basename — Return registered id from the given base name and sequence number.
Function register_with_basename — Register the given id using the given base name.
Function register_with_basename
Function template register_with_basename
Function unregister_with_basename — Unregister the given id using the given base name.
Header <hpx/runtime/components/binpacking_distribution_policy.hpp>
Struct binpacking_distribution_policy
Global default_binpacking_counter_name
Global binpacked
Header <hpx/runtime/components/colocating_distribution_policy.hpp>
Struct colocating_distribution_policy
Global colocated
Header <hpx/runtime/components/component_factory.hpp>
Macro HPX_REGISTER_COMPONENT — Define a component factory for a component type.
Header <hpx/runtime/components/copy_component.hpp>
Function template copy — Copy given component to the specified target locality.
Function template copy — Copy given component to the specified target locality.
Function template copy — Copy given component to the specified target locality.
Header <hpx/runtime/components/default_distribution_policy.hpp>
Struct default_distribution_policy
Global default_layout
Header <hpx/runtime/components/migrate_component.hpp>
Function template migrate
Function template migrate
Function template migrate
Function template migrate
Header <hpx/runtime/components/new.hpp>
Function template new_ — Create one or more new instances of the given Component type on the specified locality.
Function template local_new — Create one new instance of the given Component type on the current locality.
Function template new_ — Create multiple new instances of the given Component type on the specified locality.
Function template new_ — Create one or more new instances of the given Component type based on the given distribution policy.
Function template new_ — Create multiple new instances of the given Component type on the localities as defined by the given distribution policy.
Header <hpx/runtime/find_here.hpp>
Function find_here — Return the global id representing this locality.
Header <hpx/runtime/find_localities.hpp>
Function find_root_locality — Return the global id representing the root locality.
Function find_all_localities — Return the list of global ids representing all localities available to this application.
Function find_all_localities — Return the list of global ids representing all localities available to this application which support the given component type.
Function find_remote_localities — Return the list of locality ids of remote localities supporting the given component type. By default this function will return the list of all remote localities (all but the current locality).
Function find_remote_localities — Return the list of locality ids of remote localities supporting the given component type. By default this function will return the list of all remote localities (all but the current locality).
Function find_locality — Return the global id representing an arbitrary locality which supports the given component type.
Header <hpx/runtime/get_colocation_id.hpp>
Function get_colocation_id — Return the id of the locality where the object referenced by the given id is currently located on.
Function get_colocation_id — Asynchronously return the id of the locality where the object referenced by the given id is currently located on.
Header <hpx/runtime/get_locality_id.hpp>
Function get_locality_id — Return the number of the locality this function is being called from.
Header <hpx/runtime/get_locality_name.hpp>
Function get_locality_name — Return the name of the locality this function is called on.
Function get_locality_name — Return the name of the referenced locality.
Header <hpx/runtime/get_num_localities.hpp>
Function get_initial_num_localities — Return the number of localities which were registered at startup for the running application.
Function get_num_localities — Asynchronously return the number of localities which are currently registered for the running application.
Function get_num_localities — Return the number of localities which are currently registered for the running application.
Function get_num_localities — Asynchronously return the number of localities which are currently registered for the running application.
Function get_num_localities — Synchronously return the number of localities which are currently registered for the running application.
Header <hpx/runtime/get_os_thread_count.hpp>
Function get_os_thread_count — Return the number of worker OS- threads used by the given executor to execute HPX threads.
Header <hpx/runtime/get_ptr.hpp>
Function template get_ptr — Returns a future referring to the pointer to the underlying memory of a component.
Function template get_ptr — Returns a future referring to the pointer to the underlying memory of a component.
Function template get_ptr — Returns the pointer to the underlying memory of a component.
Function template get_ptr — Returns the pointer to the underlying memory of a component.
Header <hpx/runtime/get_thread_name.hpp>
Function get_thread_name — Return the name of the calling thread.
Header <hpx/runtime/get_worker_thread_num.hpp>
Function get_worker_thread_num — Return the number of the current OS-thread running in the runtime instance the current HPX-thread is executed with.
Function get_worker_thread_num — Return the number of the current OS-thread running in the runtime instance the current HPX-thread is executed with.
Header <hpx/runtime/launch_policy.hpp>
Struct launch — Launch policies for hpx::async etc.
Header <hpx/runtime/naming/unmanaged.hpp>
Function unmanaged
Header <hpx/runtime/report_error.hpp>
Header <hpx/runtime/runtime_mode.hpp>
Type runtime_mode
Function get_runtime_mode_name
Function get_runtime_mode_from_name
Header <hpx/runtime/set_parcel_write_handler.hpp>
Type definition parcel_write_handler_type
Function set_parcel_write_handler
Header <hpx/runtime/shutdown_function.hpp>
Type definition shutdown_function_type
Function register_pre_shutdown_function — Add a function to be executed by a HPX thread during hpx::finalize() but guaranteed before any shutdown function is executed (system-wide)
Function register_shutdown_function — Add a function to be executed by a HPX thread during hpx::finalize() but guaranteed after any pre-shutdown function is executed (system-wide)
Header <hpx/runtime/startup_function.hpp>
Type definition startup_function_type
Function register_pre_startup_function — Add a function to be executed by a HPX thread before hpx_main but guaranteed before any startup function is executed (system-wide).
Function register_startup_function — Add a function to be executed by a HPX thread before hpx_main but guaranteed after any pre-startup function is executed (system-wide).
Header <hpx/runtime/threads/thread_data_fwd.hpp>
Function get_self
Function get_self_ptr
Function get_ctx_ptr
Function get_self_ptr_checked
Function get_self_id
Function get_parent_id
Function get_parent_phase
Function get_self_stacksize
Function get_parent_locality_id
Function get_self_component_id
Function get_thread_count
Function get_thread_count
Function enumerate_threads
Header <hpx/runtime/threads/thread_enums.hpp>
Type thread_state_enum
Type thread_priority
Type thread_state_ex_enum
Type thread_stacksize
Function get_thread_state_name
Function get_thread_priority_name
Function get_thread_state_ex_name
Function get_thread_state_name
Function get_stack_size_name
Header <hpx/runtime/threads/thread_helpers.hpp>
Function suspend
Function suspend
Function suspend
Function suspend
Function suspend
Function suspend
Function suspend
Function get_executor
Function get_pool
Function set_thread_state — Set the thread state of the thread referenced by the thread_id id.
Function set_thread_state — Set the thread state of the thread referenced by the thread_id id.
Function set_thread_state — Set the thread state of the thread referenced by the thread_id id.
Function get_thread_description
Function get_thread_state
Function get_thread_phase
Function get_thread_interruption_enabled
Function set_thread_interruption_enabled
Function get_thread_interruption_requested
Function interrupt_thread
Function interruption_point
Function get_thread_priority
Function get_stack_size
Function get_executor
Function get_pool
Header <hpx/runtime/threads/thread_pool_base.hpp>
Class thread_pool_base — The base class used to manage a pool of OS threads.
Header <hpx/runtime/trigger_lco.hpp>
Function trigger_lco_event — Trigger the LCO referenced by the given id.
Function trigger_lco_event — Trigger the LCO referenced by the given id.
Function trigger_lco_event — Trigger the LCO referenced by the given id.
Function trigger_lco_event — Trigger the LCO referenced by the given id.
Function template set_lco_value — Set the result value for the LCO referenced by the given id.
Function template set_lco_value — Set the result value for the (managed) LCO referenced by the given id.
Function template set_lco_value_unmanaged — Set the result value for the (unmanaged) LCO referenced by the given id.
Function template set_lco_value — Set the result value for the LCO referenced by the given id.
Function template set_lco_value — Set the result value for the (managed) LCO referenced by the given id.
Function template set_lco_value_unmanaged — Set the result value for the (unmanaged) LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Function set_lco_error — Set the error state for the LCO referenced by the given id.
Header <hpx/runtime_fwd.hpp>
Function register_thread
Function unregister_thread
Function get_runtime_instance_number
Function is_starting — Test whether the runtime system is currently being started.
Function tolerate_node_faults — Test if HPX runs in fault-tolerant mode.
Function is_running — Test whether the runtime system is currently running.
Function is_stopped — Test whether the runtime system is currently stopped.
Function is_stopped_or_shutting_down — Test whether the runtime system is currently being shut down.
Function get_num_worker_threads — Return the number of worker OS- threads used to execute HPX threads.
Function get_system_uptime — Return the system uptime measure on the thread executing this call.
Function start_active_counters — Start all active performance counters, optionally naming the section of code.
Function reset_active_counters — Resets all active performance counters.
Function reinit_active_counters — Re-initialize all active performance counters.
Function stop_active_counters — Stop all active performance counters.
Function evaluate_active_counters — Evaluate and output all active performance counters, optionally naming the point in code marked by this function.
Function create_binary_filter — Create an instance of a binary filter plugin.
Header <hpx/throw_exception.hpp>
Macro HPX_THROW_EXCEPTION — Throw a hpx::exception initialized from the given parameters.
Macro HPX_THROWS_IF — Either throw a hpx::exception or initialize hpx::error_code from the given parameters.
Header <hpx/traits/is_execution_policy.hpp>
Struct template is_async_execution_policy
Struct template is_execution_policy
Struct template is_parallel_execution_policy
Struct template is_sequenced_execution_policy
Header <hpx/util/checkpoint.hpp>
Class checkpoint
Function operator<<
Function operator>>
Function template save_checkpoint
Function template save_checkpoint
Function template save_checkpoint
Function template save_checkpoint
Function template save_checkpoint
Function template save_checkpoint
Function template restore_checkpoint
Header <hpx/util/debugging.hpp>
Function attach_debugger
Header <hpx/util/invoke.hpp>
Function template invoke
Function template invoke_r
Header <hpx/util/invoke_fused.hpp>
Function template invoke_fused
Function template invoke_fused_r
Header <hpx/util/pack_traversal.hpp>
Function template map_pack
Header <hpx/util/pack_traversal_async.hpp>
Function template traverse_pack_async
Header <hpx/util/unwrap.hpp>
Struct unwrap
Struct unwrap_all
Struct template unwrap_n
Function template unwrap
Function template unwrap_n
Function template unwrap_all
Function template unwrapping
Function template unwrapping_n
Function template unwrapping_all

The STE||AR Group (Systems Technology, Emergent Parallelism, and Algorithm Research) is an international research group with the goal of promoting the development of scalable parallel applications by providing a community for ideas, a framework for collaboration, and a platform for communicating these concepts to the broader community. The main contributors to HPX in the STE||AR Group are researchers from Louisiana State University (LSU)'s Center for Computation and Technology (CCT) and the Friedrich-Alexander University Erlangen-Nuremberg (FAU)'s Department of Computer Science 3 - Computer Architecture. For a full list of people working in this group and participating in writing this documentation see People.

This documentation is automatically generated for HPX V1.1.0 (from Git commit: 3a95a3cd5f00d7b957b06b3d8047387a7d775bd4) by the Boost QuickBook and AutoIndex documentation tools. QuickBook and AutoIndex can be found in the collection of Boost Tools.


The development of High Performance ParalleX (HPX) began in 2007. At that time, Hartmut Kaiser became interested in the work done by the ParalleX group at the Center for Computation and Technology (CCT), a multi-disciplinary research institute at Louisiana State University (LSU). The ParalleX group was working to develop a new and experimental execution model for future high performance computing architectures. This model was christened ParalleX. The first implementations of ParalleX were crude, and many of those designs had to be discarded entirely. However, over time the team learned quite a bit about how to design a parallel, distributed runtime system which implements the concepts of ParalleX.

From the very beginning, this endeavour has been a group effort. In addition to a handful of interested researchers, there have always been graduate and undergraduate students participating in the discussions, design, and implementation of HPX. In 2011 we decided to formalize our collective research efforts by creating the STE||AR group (Systems Technology, Emergent Parallelism, and Algorithm Research). Over time, the team grew to include researchers around the country and the world. In 2014, the STE||AR Group was reorganized to become the international community it is today. This consortium of researchers aims to develop stable, sustainable, and scalable tools which will enable application developers to exploit the parallelism latent in the machines of today and tomorrow. Our goal of the HPX project is to create a high quality, freely available, open source implementation of ParalleX concepts for conventional and future systems by building a modular and standards conforming runtime system for SMP and distributed application environments. The API exposed by HPX is conformant to the interfaces defined by the C++11/14 ISO standard and adheres to the programming guidelines used by the Boost collection of C++ libraries. We steer the development of HPX with real world applications and aim to provide a smooth migration path for domain scientists.

To learn more about STE||AR and ParalleX, see People and Introduction.

How to use this manual

Some icons are used to mark certain topics indicative of their relevance. These icons precede some text to indicate:

Table 1. Icons





Generally useful information (an aside that doesn't fit in the flow of the text)


Suggestion on how to do something (especially something that is not obvious)


Important note on something to take particular notice of


Take special care with this - it may not be what you expect and may cause bad results

The following table describes the syntax that will be used to refer to functions and classes throughout the manual:

Table 2. Syntax for Code References




The function foo


The template function foo (used only for template functions that require explicit parameters)


The class foo


The class template foo


Please feel free to direct questions to HPX's mailing list: hpx-users@stellar.cct.lsu.edu or log onto our IRC channel which can be found at #ste||ar at Freenode.

General Changes

Here are some of the main highlights and changes for this release (in no particular order):

  • We have changed the way HPX manages the processing units on a node. We do not longer implicitly bind all available cores to a single thread pool. The user has now full control over what processing units are bound to what thread pool, each with a separate scheduler. It is now also possible to create your own scheduler implementation and control what processing units this scheduler should use. We added the hpx::resource::partitioner that manages all available processing units and assigns resources to the used thread pools. Thread pools can be now be suspended/resumed independently. This functionality helps in running HPX concurrently to code that is directly relying on OpenMP and/or MPI.
  • We have continued to implement various parallel algorithms. HPX now almost completely implements all of the parallel algorithms as specified by the C++17 Standard. We have also continued to implement these algorithms for the distributed use case (for segmented data structures, such as hpx::partitioned_vector).
  • Added a compatibility layer for std::thread, std::mutex, and std::condition_variable allowing for the code to use those facilities where available and to fall back to the corresponding Boost facilities otherwise. The CMake configuration option -DHPX_WITH_THREAD_COMPATIBILITY=On can be used to force using the Boost equivalents.
  • The parameter sequence for the hpx::parallel::transform_inclusive_scan overload taking one iterator range has changed (again) to match the changes this algorithm has undergone while being moved to C++17. The old overloads can be still enabled at configure time by passing -DHPX_WITH_TRANSFORM_REDUCE_COMPATIBILITY=On to CMake.
  • The parameter sequence for the hpx::parallel::inclusive_scan overload taking one iterator range has changed to match the changes this algorithm has undergone while being moved to C++17. The old overloads can be still enabled at configure time by passing -DHPX_WITH_INCLUSIVE_SCAN_COMPATIBILITY=On to CMake.
  • Added a helper facility hpx::local_new which is equivalent to hpx::new_ except that it creates components locally only. As a consequence, the used component constructor may accept non-serializable argument types and/or non-const references or pointers.
  • Removed the (broken) component type hpx::lcos::queue<T>. The old type is still available at configure time by passing -DHPX_WITH_QUEUE_COMPATIBILITY=On to CMake.
  • The parallel algorithms adopted for C++17 restrict the iterator categories usable with those to at least forward iterators. Our implementation of the parallel algorithms was supporting input iterators (and output iterators) as well by simply falling back to sequential execution. We have now made our implementations conforming by requiring at least forward iterators. In order to enable the old behavior use the the compatibility option -DHPX_WITH_ALGORITHM_INPUT_ITERATOR_SUPPORT=On on the CMake command line.
  • We have added the functionalities allowing for LCOs being implemented using (simple) components. Before LCOs had to always be implemented using managed components.
  • User defined components don't have to be default-constructible anymore. Return types from actions don't have to be default-constructible anymore either. Our serialization layer now in general supports non-default-constructible types.
  • We have added a new launch policy hpx::launch::lazy that allows to defer the decision on what launch policy to use to the point of execution. This policy is initialized with a function (object) that -- when invoked -- is expected to produce the desired launch policy.
Breaking Changes
  • We have dropped support for the gcc compiler version V4.8. The minimal gcc version we now test on is gcc V4.9. The minimally required version of CMake is now V3.3.2.
  • We have dropped support for the Visual Studio 2013 compiler version. The minimal Visual Studio version we now test on is Visual Studio 2015.5.
  • We have dropped support for the Boost V1.51-V1.54. The minimal version of Boost we now test is Boost V1.55.
  • We have dropped support for the hpx::util::unwrapped API. hpx::util::unwrapped will stay functional to some degree, until it finally gets removed in a later version of HPX. The functional usage of hpx::util::unwrapped should be changed to the new hpx::util::unwrapping function whereas the immediate usage should be replaced to hpx::util::unwrap.
  • The performance counter names referring to properties as exposed by the threading subsystem have changes as those now additionally have to specify the thread-pool. See the corresponding documentation for more details.
  • The overloads of hpx::async that invoke an action do not perform implicit unwrapping of the returned future anymore in case the invoked function does return a future in the first place. In this case hpx::async now returns a hpx::future<future<T>> making its behavior conforming to its local counterpart.
  • We have replaced the use of boost::exception_ptr in our APIs with the equivalent std::exception_ptr. Please change your codes accordingly. No compatibility settings are provided.
  • We have removed the compatibility settings for HPX_WITH_COLOCATED_BACKWARDS_COMPATIBILITY and HPX_WITH_COMPONENT_GET_GID_COMPATIBILITY as their life-cycle has reached its end.
  • We have removed the experimental thread schedulers hierarchy_scheduler, periodic_priority_scheduler and throttling_scheduler in an effort to clean up and consolidate our thread schedulers.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • PR#3250 - Apex refactoring with guids
  • PR#3249 - Updating People.qbk
  • PR#3246 - Assorted fixes for CUDA
  • PR#3245 - Apex refactoring with guids
  • PR#3242 - Modify task counting in thread_queue.hpp
  • PR#3240 - Fixed typos
  • PR#3238 - Readding accidently removed std::abort
  • PR#3237 - Adding Pipeline example
  • PR#3236 - Fixing memory_block
  • PR#3233 - Make schedule_thread take suspended threads into account
  • IS#3226 - memory_block is breaking, signaling SIGSEGV on a thread on creation and freeing
  • PR#3225 - Applying quick fix for hwloc-2.0
  • IS#3224 - HPX counters crashing the application
  • PR#3223 - Fix returns when setting config entries
  • IS#3222 - Errors linking libhpx.so
  • IS#3221 - HPX on Mac OS X with HWLoc 2.0.0 fails to run
  • PR#3216 - Reorder a variadic array to satisfy VS 2017 15.6
  • PR#3214 - Changed prerequisites.qbk to avoid confusion while building boost
  • PR#3213 - Relax locks for thread suspension to avoid holding locks when yielding
  • PR#3212 - Fix check in sequenced_executor test
  • PR#3211 - Use preinit_array to set argc/argv in init_globally example
  • PR#3210 - Adapted parallel::{search | search_n} for Ranges TS (see #1668)
  • PR#3209 - Fix locking problems during shutdown
  • IS#3208 - init_globally throwing a run-time error
  • PR#3206 - Addition of new arithmetic performance counter "Count"
  • PR#3205 - Fixing return type calculation for bulk_then_execute
  • PR#3204 - Changing std::rand() to a better inbuilt PRNG generator
  • PR#3203 - Resolving problems during shutdown for VS2015
  • PR#3202 - Making sure resource partitioner is not accessed if its not valid
  • PR#3201 - Fixing optional::swap
  • IS#3200 - hpx::util::optional fails
  • PR#3199 - Fix sliding_semaphore test
  • PR#3198 - Set pre_main status before launching run_helper
  • PR#3197 - Update README.rst
  • PR#3194 - parallel::{fill|fill_n} updated for Ranges TS
  • PR#3193 - Updating Runtime.cpp by adding correct description of Performance counters during register
  • PR#3191 - Fix sliding_semaphore_2338 test
  • PR#3190 - Topology improvements
  • PR#3189 - Deleting one include of median from BOOST library to arithmetics_counter file
  • PR#3188 - Optionally disable printing of diagnostics during terminate
  • PR#3187 - Suppressing cmake warning issued by cmake > V3.11
  • PR#3185 - Remove unused scoped_unlock, unlock_guard_try
  • PR#3184 - Fix nqueen example
  • PR#3183 - Add runtime start/stop, resume/suspend and OpenMP benchmarks
  • IS#3182 - bulk_then_execute has unexpected return type/does not compile
  • IS#3181 - hwloc 2.0 breaks topo class and cannot be used
  • IS#3180 - Schedulers that don't support suspend/resume are unusable
  • PR#3179 - Various minor changes to support FLeCSI
  • PR#3178 - Fix #3124
  • PR#3177 - Removed allgather
  • PR#3176 - Fixed Documentation for "using_hpx_pkgconfig"
  • PR#3174 - Add hpx::iostreams::ostream overload to format_to
  • PR#3172 - Fix lifo queue backend
  • PR#3171 - adding the missing unset() function to cpu_mask() for case of more than 64 threads
  • PR#3170 - Add cmake flag -DHPX_WITH_FAULT_TOLERANCE=ON (OFF by default)
  • PR#3169 - Adapted parallel::{count|count_if} for Ranges TS (see #1668)
  • PR#3168 - Changing used namespace for seq execution policy
  • IS#3167 - Update GSoC projects
  • IS#3166 - Application (Octotiger) gets stuck on hpx::finalize when only using one thread
  • IS#3165 - Compilation of parallel algorithms with HPX_WITH_DATAPAR is broken
  • PR#3164 - Fixing component migration
  • PR#3162 - regex_from_pattern: escape regex special characters to avoid misinterpretation
  • IS#3161 - Building HPX with hwloc 2.0.0 fails
  • PR#3160 - Fixing the handling of quoted command line arguments.
  • PR#3158 - Fixing a race with timed suspension (second attempt)
  • PR#3157 - Revert "Fixing a race with timed suspension"
  • PR#3156 - Fixing serialization of classes with incompatible serialize signature
  • PR#3154 - More refactorings based on clang-tidy reports
  • PR#3153 - Fixing a race with timed suspension
  • PR#3152 - Documentation for runtime suspension
  • PR#3151 - Use small_vector only from boost version 1.59 onwards
  • PR#3150 - Avoiding more stack overflows
  • PR#3148 - Refactoring component_base and base_action/transfer_base_action
  • PR#3147 - Move yield_while out of detail namespace and into own file
  • PR#3145 - Remove a leftover of the cxx11 std array cleanup
  • PR#3144 - Minor changes to how actions are executed
  • PR#3143 - Fix stack overhead
  • PR#3142 - Fix typo in config.hpp
  • PR#3141 - Fixing small_vector compatibility with older boost version
  • PR#3140 - is_heap_text fix
  • IS#3139 - Error in is_heap_tests.hpp
  • PR#3138 - Partially reverting #3126
  • PR#3137 - Suspend speedup
  • PR#3136 - Revert "Fixing #2325"
  • PR#3135 - Improving destruction of threads
  • IS#3134 - HPX_SERIALIZATION_SPLIT_FREE does not stop compiler from looking for serialize() method
  • PR#3133 - Make hwloc compulsory
  • PR#3132 - Update CXX14 constexpr feature test
  • PR#3131 - Fixing #2325
  • PR#3130 - Avoid completion handler allocation
  • PR#3129 - Suspend runtime
  • PR#3128 - Make docbook dtd and xsl path names consistent
  • PR#3127 - Add hpx::start nullptr overloads
  • PR#3126 - Cleaning up coroutine implementation
  • PR#3125 - Replacing nullptr with hpx::threads::invalid_thread_id
  • IS#3124 - Add hello_world_component to CI builds
  • PR#3123 - Add new constructor.
  • PR#3122 - Fixing #3121
  • IS#3121 - HPX_SMT_PAUSE is broken on non-x86 platforms when __GNUC__ is defined
  • PR#3120 - Don't use boost::intrusive_ptr for thread_id_type
  • PR#3119 - Disable default executor compatibility with V1 executors
  • PR#3118 - Adding performance_counter::reinit to allow for dynamically changing counter sets
  • PR#3117 - Replace uses of boost/experimental::optional with util::optional
  • PR#3116 - Moving background thread APEX timer #2980
  • PR#3115 - Fixing race condition in channel test
  • PR#3114 - Avoid using util::function for thread function wrappers
  • PR#3113 - cmake V3.10.2 has changed the variable names used for MPI
  • PR#3112 - Minor fixes to exclusive_scan algorithm
  • PR#3111 - Revert "fix detection of cxx11_std_atomic"
  • PR#3110 - Suspend thread pool
  • PR#3109 - Fixing thread scheduling when yielding a thread id
  • PR#3108 - Revert "Suspend thread pool"
  • PR#3107 - Remove UB from thread::id relational operators
  • PR#3106 - Add cmake test for std::decay_t to fix cuda build
  • PR#3105 - Fixing refcount for async traversal frame
  • PR#3104 - Local execution of direct actions is now actually performed directly
  • PR#3103 - Adding support for generic counter_raw_values performance counter type
  • IS#3102 - Introduce generic performance counter type returning an array of values
  • PR#3101 - Revert "Adapting stack overhead limit for gcc 4.9"
  • PR#3100 - Fix #3068 (condition_variable deadlock)
  • PR#3099 - Fixing lock held during suspension in papi counter component
  • PR#3098 - Unbreak broadcast_wait_for_2822 test
  • PR#3097 - Adapting stack overhead limit for gcc 4.9
  • PR#3096 - fix detection of cxx11_std_atomic
  • PR#3095 - Add ciso646 header to get _LIBCPP_VERSION for testing inplace merge
  • PR#3094 - Relax atomic operations on performance counter values
  • PR#3093 - Short-circuit all_of/any_of/none_of instantiations
  • PR#3092 - Take advantage of C++14 lambda capture initialization syntax, where possible
  • PR#3091 - Remove more references to Boost from logging code
  • PR#3090 - Unify use of yield/yield_k
  • PR#3089 - Fix a strange thing in parallel::detail::handle_exception. (Fix #2834.)
  • IS#3088 - A strange thing in parallel::sort.
  • PR#3087 - Fixing assertion in default_distribution_policy
  • PR#3086 - Implement parallel::remove and parallel::remove_if
  • PR#3085 - Addressing breaking changes in Boost V1.66
  • PR#3084 - Ignore build warnings round 2
  • PR#3083 - Fix typo HPX_WITH_MM_PREFECTH
  • PR#3081 - Pre-decay template arguments early
  • PR#3080 - Suspend thread pool
  • PR#3079 - Ignore build warnings
  • PR#3078 - Don't test inplace_merge with libc++
  • PR#3076 - Fixing 3075: Part 1
  • PR#3074 - Fix more build warnings
  • PR#3073 - Suspend thread cleanup
  • PR#3072 - Change existing symbol_namespace::iterate to return all data instead of invoking a callback
  • PR#3071 - Fixing pack_traversal_async test
  • PR#3070 - Fix dynamic_counters_loaded_1508 test by adding dependency to memory_component
  • PR#3069 - Fix scheduling loop exit
  • IS#3068 - hpx::lcos::condition_variable could be suspect to deadlocks
  • PR#3067 - #ifdef out random_shuffle deprecated in later c++
  • PR#3066 - Make coalescing test depend on coalescing library to ensure it gets built
  • PR#3065 - Workaround for minimal_timed_async_executor_test compilation failures, attempts to copy a deferred call (in unevaluated context)
  • PR#3064 - Fixing wrong condition in wrapper_heap
  • PR#3062 - Fix exception handling for execution::seq
  • PR#3061 - Adapt MSVC C++ mode handling to VS15.5
  • PR#3060 - Fix compiler problem in MSVC release mode
  • PR#3059 - Fixing #2931
  • IS#3058 - minimal_timed_async_executor_test_exe fails to compile on master (d6f505c)
  • PR#3057 - Fix stable_merge_2964 compilation problems
  • PR#3056 - Fix some build warnings caused by unused variables/unnecessary tests
  • PR#3055 - Update documentation for running tests
  • IS#3054 - Assertion failure when using bulk hpx::new_ in asynchronous mode
  • PR#3052 - Do not bind test running to cmake test build rule
  • PR#3051 - Fix HPX-Qt interaction in Qt example.
  • IS#3048 - nqueen example fails occasionally
  • PR#3047 - Fixing #3044
  • PR#3046 - Add OS thread suspension
  • PR#3042 - PyCicle - first attempt at a build toold for checking PR's
  • PR#3041 - Fix a problem about asynchronous execution of parallel::merge and parallel::partition.
  • PR#3040 - Fix a mistake about exception handling in asynchronous execution of scan_partitioner.
  • PR#3039 - Consistently use executors to schedule work
  • PR#3038 - Fixing local direct function execution and lambda actions perfect forwarding
  • PR#3035 - Make parallel unit test names match build target/folder names
  • PR#3033 - Fix setting of default build type
  • IS#3032 - Fix partitioner arg copy found in #2982
  • IS#3031 - Errors linking libhpx.so due to missing references (master branch, commit 6679a8882)
  • PR#3030 - Revert "implement executor then interface with && forwarding reference"
  • PR#3029 - Run CI inspect checks before building
  • PR#3028 - Added range version of parallel::move
  • IS#3027 - Implement all scheduling APIs in terms of executors
  • PR#3026 - implement executor then interface with && forwarding reference
  • PR#3025 - Fix typo unitialized to uninitialized
  • PR#3024 - Inspect fixes
  • PR#3023 - P0356 Simplified partial function application
  • PR#3022 - Master fixes
  • PR#3021 - Segfault fix
  • PR#3020 - Disable command-line aliasing for applications that use user_main
  • PR#3019 - Adding enable_elasticity option to pool configuration
  • PR#3018 - Fix stack overflow detection configuration in header files
  • PR#3017 - Speed up local action execution
  • PR#3016 - Unify stack-overflow detection options, remove reference to libsigsegv
  • PR#3015 - Speeding up accessing the resource partitioner and the topology info
  • IS#3014 - HPX does not compile on POWER8 with gcc 5.4
  • IS#3013 - hello_world occasionally prints multiple lines from a single OS-thread
  • PR#3012 - Silence warning about casting away qualifiers in itt_notify.hpp
  • PR#3011 - Fix cpuset leak in hwloc_topology_info.cpp
  • PR#3010 - Remove useless decay_copy
  • PR#3009 - Fixing 2996
  • PR#3008 - Remove unused internal function
  • PR#3007 - Fixing wrapper_heap alignment problems
  • IS#3006 - hwloc memory leak
  • PR#3004 - Silence C4251 (needs to have dll-interface) for future_data_void
  • IS#3003 - Suspension of runtime
  • PR#3001 - Attempting to avoid data races in async_traversal while evaluating dataflow()
  • PR#3000 - Adding hpx::util::optional as a first step to replace experimental::optional
  • PR#2998 - Cleanup up and Fixing component creation and deletion
  • IS#2996 - Build fails with HPX_WITH_HWLOC=OFF
  • PR#2995 - Push more future_data functionality to source file
  • PR#2994 - WIP: Fix throttle test
  • PR#2993 - Making sure --hpx:help does not throw for required (but missing) arguments
  • PR#2992 - Adding non-blocking (on destruction) service executors
  • IS#2991 - run_as_os_thread locks up
  • IS#2990 - --help will not work until all required options are provided
  • PR#2989 - Improve error messages caused by misuse of dataflow
  • PR#2988 - Improve error messages caused by misuse of .then
  • IS#2987 - stack overflow detection producing false positives
  • PR#2986 - Deduplicate non-dependent thread_info logging types
  • PR#2985 - Adapted parallel::{all_of|any_of|none_of} for Ranges TS (see #1668)
  • PR#2984 - Refactor one_size_heap code to simplify code
  • PR#2983 - Fixing local_new_component
  • PR#2982 - Clang tidy
  • PR#2981 - Simplify allocator rebinding in pack traversal
  • PR#2979 - Fixing integer overflows
  • PR#2978 - Implement parallel::inplace_merge
  • IS#2977 - Make hwloc compulsory instead of optional
  • PR#2976 - Making sure client_base instance that registered the component does not unregister it when being destructed
  • PR#2975 - Change version of pulled APEX to master
  • PR#2974 - Fix domain not being freed at the end of scheduling loop
  • PR#2973 - Fix small typos
  • PR#2972 - Adding uintstd.h header
  • PR#2971 - Fall back to creating local components using local_new
  • PR#2970 - Improve is_tuple_like trait
  • PR#2969 - Fix HPX_WITH_MORE_THAN_64_THREADS default value
  • PR#2968 - Cleaning up dataflow overload set
  • PR#2967 - Make parallel::merge is stable. (Fix #2964.)
  • PR#2966 - Fixing a couple of held locks during exception handling
  • PR#2965 - Adding missing #include
  • IS#2964 - parallel merge is not stable
  • PR#2963 - Making sure any function object passed to dataflow is released after being invoked
  • PR#2962 - Partially reverting #2891
  • PR#2961 - Attempt to fix the gcc 4.9 problem with the async pack traversal
  • IS#2959 - Program terminates during error handling
  • IS#2958 - HPX_PLAIN_ACTION breaks due to missing include
  • PR#2957 - Fixing errors generated by mixing different attribute syntaxes
  • IS#2956 - Mixing attribute syntaxes leads to compiler errors
  • IS#2955 - Fix OS-Thread throttling
  • PR#2953 - Making sure any hpx.os_threads=N supplied through a --hpx::config file is taken into account
  • PR#2952 - Removing wrong call to cleanup_terminated_locked
  • PR#2951 - Revert "Make sure the function vtables are initialized before use"
  • PR#2950 - Fix a namespace compilation error when some schedulers are disabled
  • IS#2949 - master branch giving lockups on shutdown
  • IS#2947 - hpx.ini is not used correctly at initialization
  • PR#2946 - Adding explicit feature test for thread_local
  • PR#2945 - Make sure the function vtables are initialized before use
  • PR#2944 - Attempting to solve affinity problems on CircleCI
  • PR#2943 - Changing channel actions to be direct
  • PR#2942 - Adding split_future for std::vector
  • PR#2941 - Add a feature test to test for CXX11 override
  • IS#2940 - Add split_future for future<vector<T>>
  • PR#2939 - Making error reporting during problems with setting affinity masks more verbose
  • PR#2938 - Fix this various executors
  • PR#2937 - Fix some typos in documentation
  • PR#2934 - Remove the need for "complete" SFINAE checks
  • PR#2933 - Making sure parallel::for_loop is executed in parallel if requested
  • PR#2932 - Classify chunk_size_iterator to input iterator tag. (Fix #2866)
  • IS#2931 - --hpx:help triggers unusual error with clang build
  • PR#2930 - Add #include files needed to set _POSIX_VERSION for debug check
  • PR#2929 - Fix a couple of deprecated c++ features
  • PR#2928 - Fixing execution parameters
  • IS#2927 - CMake warning: ... cycle in constraint graph
  • PR#2926 - Default pool rename
  • IS#2925 - Default pool cannot be renamed
  • IS#2924 - hpx:attach-debugger=startup does not work any more
  • PR#2923 - Alloc membind
  • PR#2922 - This fixes CircleCI errors when running with --hpx:bind=none
  • PR#2921 - Custom pool executor was missing priority and stacksize options
  • PR#2920 - Adding test to trigger problem reported in #2916
  • PR#2919 - Make sure the resource_partitioner is properly destructed on hpx::finalize
  • IS#2918 - hpx::init calls wrong (first) callback when called multiple times
  • PR#2917 - Adding util::checkpoint
  • IS#2916 - Weird runtime failures when using a channel and chained continuations
  • PR#2915 - Introduce executor parameters customization points
  • IS#2914 - Task assignment to current Pool has unintended consequences
  • PR#2913 - Fix rp hang
  • PR#2912 - Update contributors
  • PR#2911 - Fixing CUDA problems
  • PR#2910 - Improve error reporting for process component on POSIX systems
  • PR#2909 - Fix typo in include path
  • PR#2908 - Use proper container according to iterator tag in benchmarks of parallel algorithms
  • PR#2907 - Optionaly force-delete remaining channel items on close
  • PR#2906 - Making sure generated performance counter names are correct
  • IS#2905 - collecting idle-rate performance counters on multiple localities produces an error
  • IS#2904 - build broken for Intel 17 compilers
  • PR#2903 - Documentation Updates-- Adding New People
  • PR#2902 - Fixing service_executor
  • PR#2901 - Fixing partitioned_vector creation
  • PR#2900 - Add numa-balanced mode to hpx::bind, spread cores over numa domains
  • IS#2899 - hpx::bind does not have a mode that balances cores over numa domains
  • PR#2898 - Adding missing #include and missing guard for optional code section
  • PR#2897 - Removing dependency on Boost.ICL
  • IS#2896 - Debug build fails without -fpermissive with GCC 7.1 and Boost 1.65
  • PR#2895 - Fixing SLURM environment parsing
  • PR#2894 - Fix incorrect handling of compile definition with value 0
  • IS#2893 - Disabling schedulers causes build errors
  • PR#2892 - added list serializer
  • PR#2891 - Resource Partitioner Fixes
  • IS#2890 - Destroying a non-empty channel causes an assertion failure
  • PR#2889 - Add check for libatomic
  • PR#2888 - Fix compilation problems if HPX_WITH_ITT_NOTIFY=ON
  • PR#2887 - Adapt broadcast() to non-unwrapping async<Action>
  • PR#2886 - Replace Boost.Random with C++11 <random>
  • IS#2885 - regression in broadcast?
  • IS#2884 - linking -latomic is not portable
  • PR#2883 - Explicitly set -pthread flag if available
  • PR#2882 - Wrap boost::format uses
  • IS#2881 - hpx not compiling with HPX_WITH_ITTNOTIFY=On
  • IS#2880 - hpx::bind scatter/balanced give wrong pu masks
  • PR#2878 - Fix incorrect pool usage masks setup in RP/thread manager
  • PR#2877 - Require std::array by default
  • PR#2875 - Deprecate use of BOOST_ASSERT
  • PR#2874 - Changed serialization of boost.variant to use variadic templates
  • IS#2873 - building with parcelport_mpi fails on cori
  • PR#2871 - Adding missing support for throttling scheduler
  • PR#2870 - Disambiguate use of base_lco_with_value macros with channel
  • IS#2869 - Difficulty compiling HPX_REGISTER_CHANNEL_DECLARATION(double)
  • PR#2868 - Removing uneeded assert
  • PR#2867 - Implement parallel::unique
  • IS#2866 - The chunk_size_iterator violates multipass guarantee
  • PR#2865 - Only use sched_getcpu on linux machines
  • PR#2864 - Create redistribution archive for successful builds
  • PR#2863 - Replace casts/assignments with hard-coded memcpy operations
  • IS#2862 - sched_getcpu not available on MacOS
  • PR#2861 - Fixing unmatched header defines and recursive inclusion of threadmanager
  • IS#2860 - Master program fails with assertion 'type == data_type_address' failed: HPX(assertion_failure)
  • IS#2852 - Support for ARM64
  • PR#2858 - Fix misplaced #if #endif's that cause build failure without THREAD_CUMULATIVE_COUNTS
  • PR#2857 - Fix some listing in documentation
  • PR#2856 - Fixing component handling for lcos
  • PR#2855 - Add documentation for coarrays
  • PR#2854 - Support ARM64 in timestamps
  • PR#2853 - Update Table 17. Non-modifying Parallel Algorithms in Documentation
  • PR#2851 - Allowing for non-default-constructible component types
  • PR#2850 - Enable returning future<R> from actions where R is not default-constructible
  • PR#2849 - Unify serialization of non-default-constructable types
  • IS#2848 - Components have to be default constructible
  • IS#2847 - Returning a future<R> where R is not default-constructable broken
  • IS#2846 - Unify serialization of non-default-constructible types
  • PR#2845 - Add Visual Studio 2015 to the tested toolchains in Appveyor
  • IS#2844 - Change the appveyor build to use the minimal required MSVC version
  • IS#2843 - multi node hello_world hangs
  • PR#2842 - Correcting Spelling mistake in docs
  • PR#2841 - Fix usage of std::aligned_storage
  • PR#2840 - Remove constexpr from a void function
  • IS#2839 - memcpy buffer overflow: load_construct_data() and std::complex members
  • IS#2835 - constexpr functions with void return type break compilation with CUDA 8.0
  • IS#2834 - One suspicion in parallel::detail::handle_exception
  • PR#2833 - Implement parallel::merge
  • PR#2832 - Fix a strange thing in parallel::util::detail::handle_local_exceptions. (Fix #2818)
  • PR#2830 - Break the debugger when a test failed
  • IS#2831 - parallel/executors/execution_fwd.hpp causes compilation failure in C++11 mode.
  • PR#2829 - Implement an API for asynchronous pack traversal
  • PR#2828 - Split unit test builds on CircleCI to avoid timeouts
  • IS#2827 - failure to compile hello_world example with -Werror
  • PR#2824 - Making sure promises are marked as started when used as continuations
  • PR#2823 - Add documentation for partitioned_vector_view
  • IS#2822 - Yet another issue with wait_for similar to #2796
  • PR#2821 - Fix bugs and improve that about HPX_HAVE_CXX11_AUTO_RETURN_VALUE of CMake
  • PR#2820 - Support C++11 in benchmark codes of parallel::partition and parallel::partition_copy
  • PR#2819 - Fix compile errors in unit test of container version of parallel::partition
  • IS#2818 - A strange thing in parallel::util::detail::handle_local_exceptions
  • IS#2815 - HPX fails to compile with HPX_WITH_CUDA=ON and the new CUDA 9.0 RC
  • IS#2814 - Using 'gmakeN' after 'cmake' produces error in src/CMakeFiles/hpx.dir/runtime/agas/addressing_service.cpp.o
  • PR#2813 - Properly support [[noreturn]] attribute if available
  • IS#2812 - Compilation fails with gcc 7.1.1
  • PR#2811 - Adding hpx::launch::lazy and support for async, dataflow, and future::then
  • PR#2810 - Add option allowing to disable deprecation warning
  • PR#2809 - Disable throttling scheduler if HWLOC is not found/used
  • PR#2808 - Fix compile errors on some environments of parallel::partition
  • IS#2807 - Difficulty building with HPX_WITH_HWLOC=Off
  • PR#2806 - Partitioned vector
  • PR#2805 - Serializing collections with non-default constructible data
  • PR#2802 - Fix FreeBSD 11
  • IS#2801 - Rate limiting techniques in io_service
  • IS#2800 - New Launch Policy: async_if
  • PR#2799 - Fix a unit test failure on GCC in tuple_cat
  • PR#2798 - bump minimum required cmake to 3.0 in test
  • PR#2797 - Making sure future::wait_for et.al. work properly for action results
  • IS#2796 - wait_for does always in "deferred" state for calls on remote localities
  • IS#2795 - Serialization of types without default constructor
  • PR#2794 - Fixing test for partitioned_vector iteration
  • PR#2792 - Implemented segmented find and its variations for partitioned vector
  • PR#2791 - Circumvent scary warning about placement new
  • PR#2790 - Fix OSX build
  • PR#2789 - Resource partitioner
  • PR#2788 - Adapt parallel::is_heap and parallel::is_heap_until to Ranges TS
  • PR#2787 - Unwrap hotfixes
  • PR#2786 - Update CMake Minimum Version to 3.3.2 (refs #2565)
  • IS#2785 - Issues with masks and cpuset
  • PR#2784 - Error with reduce and transform reduce fixed
  • PR#2783 - StackOverflow integration with libsigsegv
  • PR#2782 - Replace boost::atomic with std::atomic (where possible)
  • PR#2781 - Check for and optionally use [[deprecated]] attribute
  • PR#2780 - Adding empty (but non-trivial) destructor to circumvent warnings
  • PR#2779 - Exception info tweaks
  • PR#2778 - Implement parallel::partition
  • PR#2777 - Improve error handling in gather_here/gather_there
  • PR#2776 - Fix a bug in compiler version check
  • PR#2775 - Fix compilation when HPX_WITH_LOGGING is OFF
  • PR#2774 - Removing dependency on Boost.Date_Time
  • PR#2773 - Add sync_images() method to spmd_block class
  • PR#2772 - Adding documentation for PAPI counters
  • PR#2771 - Removing boost preprocessor dependency
  • PR#2770 - Adding test, fixing deadlock in config registry
  • PR#2769 - Remove some other warnings and errors detected by clang 5.0
  • IS#2768 - Is there iterator tag for HPX?
  • PR#2767 - Improvements to continuation annotation
  • PR#2765 - gcc split stack support for HPX threads #620
  • PR#2764 - Fix some uses of begin/end, remove unnecessary includes
  • PR#2763 - Bump minimal Boost version to 1.55.0
  • PR#2762 - hpx::partitioned_vector serializer
  • PR#2761 - Adding configuration summary to cmake output and --hpx:info
  • PR#2760 - Removing 1d_hydro example as it is broken
  • PR#2758 - Remove various warnings detected by clang 5.0
  • IS#2757 - In case of a "raw thread" is needed per core for implementing parallel algorithm, what is good practice in HPX?
  • PR#2756 - Allowing for LCOs to be simple components
  • PR#2755 - Removing make_index_pack_unrolled
  • PR#2754 - Implement parallel::unique_copy
  • PR#2753 - Fixing detection of [[fallthrough]] attribute
  • PR#2752 - New thread priority names
  • PR#2751 - Replace boost::exception with proposed exception_info
  • PR#2750 - Replace boost::iterator_range
  • PR#2749 - Fixing hdf5 examples
  • IS#2748 - HPX fails to build with enabled hdf5 examples
  • IS#2747 - Inherited task priorities break certain DAG optimizations
  • IS#2746 - HPX segfaulting with valgrind
  • PR#2745 - Adding extended arithmetic performance counters
  • PR#2744 - Adding ability to statistics counters to reset base counter
  • IS#2743 - Statistics counter does not support reseting
  • PR#2742 - Making sure Vc V2 builds without additional HPX configuration flags
  • PR#2741 - Deprecate unwrapped and implement unwrap and unwrapping
  • PR#2740 - Coroutine stackoverflow detection for linux/posix; Issue #2408
  • PR#2739 - Add files via upload
  • PR#2738 - Appveyor support
  • PR#2737 - Fixing 2735
  • IS#2736 - 1d_hydro example does't work
  • IS#2735 - partitioned_vector_subview test failing
  • PR#2734 - Add C++11 range utilities
  • PR#2733 - Adapting iterator requirements for parallel algorithms
  • PR#2732 - Integrate C++ Co-arrays
  • PR#2731 - Adding on_migrated event handler to migratable component instances
  • IS#2729 - Add on_migrated() event handler to migratable components
  • IS#2728 - Why Projection is needed in parallel algorithms?
  • PR#2727 - Cmake files for StackOverflow Detection
  • PR#2726 - CMake for Stack Overflow Detection
  • PR#2725 - Implemented segmented algorithms for partitioned vector
  • PR#2724 - Fix examples in Action documentation
  • PR#2723 - Enable lcos::channel<T>::register_as
  • IS#2722 - channel register_as() failing on compilation
  • PR#2721 - Mind map
  • PR#2720 - reorder forward declarations to get rid of C++14-only auto return types
  • PR#2719 - Add documentation for partitioned_vector and add features in pack.hpp
  • IS#2718 - Some forward declarations in execution_fwd.hpp aren't C++11-compatible
  • PR#2717 - Config support for fallthrough attribute
  • PR#2716 - Implement parallel::partition_copy
  • PR#2715 - initial import of icu string serializer
  • PR#2714 - initial import of valarray serializer
  • PR#2713 - Remove slashes before CMAKE_FILES_DIRECTORY variables
  • PR#2712 - Fixing wait for 1751
  • PR#2711 - Adjust code for minimal supported GCC having being bumped to 4.9
  • PR#2710 - Adding code of conduct
  • PR#2709 - Fixing UB in destroy tests
  • PR#2708 - Add inline to prevent multiple definition issue
  • IS#2707 - Multiple defined symbols for task_block.hpp in VS2015
  • PR#2706 - Adding .clang-format file
  • PR#2704 - Add a synchronous mapping API
  • IS#2703 - Request: Add the .clang-format file to the repository
  • IS#2702 - STEllAR-GROUP/Vc slower than VCv1 possibly due to wrong instructions generated
  • IS#2701 - Datapar with STEllAR-GROUP/Vc requires obscure flag
  • IS#2700 - Naming inconsistency in parallel algorithms
  • IS#2699 - Iterator requirements are different from standard in parallel copy_if.
  • PR#2698 - Properly releasing parcelport write handlers
  • IS#2697 - Compile error in addressing_service.cpp
  • IS#2696 - Building and using HPX statically: undefined references from runtime_support_server.cpp
  • IS#2695 - Executor changes cause compilation failures
  • PR#2694 - Refining C++ language mode detection for MSVC
  • PR#2693 - P0443 r2
  • PR#2692 - Partially reverting changes to parcel_await
  • IS#2689 - HPX build fails when HPX_WITH_CUDA is enabled
  • PR#2688 - Make Cuda Clang builds pass
  • PR#2687 - Add an is_tuple_like trait for sequenceable type detection
  • PR#2686 - Allowing throttling scheduler to be used without idle backoff
  • PR#2685 - Add support of std::array to hpx::util::tuple_size and tuple_element
  • PR#2684 - Adding new statistics performance counters
  • PR#2683 - Replace boost::exception_ptr with std::exception_ptr
  • IS#2682 - HPX does not compile with HPX_WITH_THREAD_MANAGER_IDLE_BACKOFF=OFF
  • PR#2681 - Attempt to fix problem in managed_component_base
  • PR#2680 - Fix bad size during archive creation
  • IS#2679 - Mismatch between size of archive and container
  • IS#2678 - In parallel algorithm, other tasks are executed to the end even if an exception occurs in any task.
  • PR#2677 - Adding include check for std::addressof
  • PR#2676 - Adding parallel::destroy and destroy_n
  • PR#2675 - Making sure statistics counters work as expected
  • PR#2674 - Turning assertions into exceptions
  • PR#2673 - Inhibit direct conversion from future<future<T>> --> future<void>
  • PR#2672 - C++17 invoke forms
  • PR#2671 - Adding uninitialized_value_construct and uninitialized_value_construct_n
  • PR#2670 - Integrate spmd multidimensionnal views for partitioned_vectors
  • PR#2669 - Adding uninitialized_default_construct and uninitialized_default_construct_n
  • PR#2668 - Fixing documentation index
  • IS#2667 - Ambiguity of nested hpx::future<void>'s
  • IS#2666 - Statistics Performance counter is not working
  • PR#2664 - Adding uninitialized_move and uninitialized_move_n
  • IS#2663 - Seg fault in managed_component::get_base_gid, possibly cause by util::reinitializable_static
  • IS#2662 - Crash in managed_component::get_base_gid due to problem with util::reinitializable_static
  • PR#2665 - Hide the detail namespace in doxygen per default
  • PR#2660 - Add documentation to hpx::util::unwrapped and hpx::util::unwrapped2
  • PR#2659 - Improve integration with vcpkg
  • PR#2658 - Unify access_data trait for use in both, serialization and de-serialization
  • PR#2657 - Removing hpx::lcos::queue<T>
  • PR#2656 - Reduce MAX_TERMINATED_THREADS default, improve memory use on manycore cpus
  • PR#2655 - Mainteinance for emulate-deleted macros
  • PR#2654 - Implement parallel is_heap and is_heap_until
  • PR#2653 - Drop support for VS2013
  • PR#2652 - This patch makes sure that all parcels in a batch are properly handled
  • PR#2649 - Update docs (Table 18) - move transform to end
  • IS#2647 - hpx::parcelset::detail::parcel_data::has_continuation_ is unitialized
  • IS#2644 - Some .vcxproj in the HPX.sln fail to build
  • IS#2641 - hpx::lcos::queue should be deprecated
  • PR#2640 - A new throttling policy with public APIs to suspend/resume
  • PR#2639 - Fix a tiny typo in tutorial.
  • IS#2638 - Invalid return type 'void' of constexpr function
  • PR#2636 - Add and use HPX_MSVC_WARNING_PRAGMA for #pragma warning
  • PR#2633 - Distributed define_spmd_block
  • PR#2632 - Making sure container serialization uses size-compatible types
  • PR#2631 - Add lcos::local::one_element_channel
  • PR#2629 - Move unordered_map out of parcelport into hpx/concurrent
  • PR#2628 - Making sure that shutdown does not hang
  • PR#2627 - Fix serialization
  • PR#2626 - Generate cmake_variables.qbk and cmake_toolchains.qbk outside of the source tree
  • PR#2625 - Supporting -std=c++17 flag
  • PR#2624 - Fixing a small cmake typo
  • PR#2622 - Update CMake minimum required version to 3.0.2 (closes #2621)
  • IS#2621 - Compiling hpx master fails with /usr/bin/ld: final link failed: Bad value
  • PR#2620 - Remove warnings due to some captured variables
  • PR#2619 - LF multiple parcels
  • PR#2618 - Some fixes to libfabric that didn't get caught before the merge
  • PR#2617 - Adding hpx::local_new
  • PR#2616 - Documentation: Extract all entities in order to autolink functions correctly
  • IS#2615 - Documentation: Linking functions is broken
  • PR#2614 - Adding serialization for std::deque
  • PR#2613 - We need to link with boost.thread and boost.chrono if we use boost.context
  • PR#2612 - Making sure for_loop_n(par, ...) is actually executed in parallel
  • PR#2611 - Add documentation to invoke_fused and friends NFC
  • PR#2610 - Added reduction templates using an identity value
  • PR#2608 - Fixing some unused vars in inspect
  • PR#2607 - Fixed build for mingw
  • PR#2606 - Supporting generic context for boost >= 1.61
  • PR#2605 - Parcelport libfabric3
  • PR#2604 - Adding allocator support to promise and friends
  • PR#2603 - Barrier hang
  • PR#2602 - Changes to scheduler to steal from one high-priority queue
  • IS#2601 - High priority tasks are not executed first
  • PR#2600 - Compat fixes
  • PR#2599 - Compatibility layer for threading support
  • PR#2598 - V1.1
  • PR#2597 - Release V1.0
  • PR#2592 - First attempt to introduce spmd_block in hpx
  • PR#2586 - local_segment in segmented_iterator_traits
  • IS#2584 - Add allocator support to promise, packaged_task and friends
  • PR#2576 - Add missing dependencies of cuda based tests
  • PR#2575 - Remove warnings due to some captured variables
  • IS#2574 - MSVC 2015 Compiler crash when building HPX
  • IS#2568 - Remove throttle_scheduler as it has been abandoned
  • IS#2566 - Add an inline versioning namespace before 1.0 release
  • IS#2565 - Raise minimal cmake version requirement
  • PR#2556 - Fixing scan partitioner
  • PR#2546 - Broadcast async
  • IS#2543 - make install fails due to a non-existing .so file
  • PR#2495 - wait_or_add_new returning thread_id_type
  • IS#2480 - Unable to register new performance counter
  • IS#2471 - no type named 'fcontext_t' in namespace
  • IS#2456 - Re-implement hpx::util::unwrapped
  • IS#2455 - Add more arithmetic performance counters
  • PR#2454 - Fix a couple of warnings and compiler errors
  • PR#2453 - Timed executor support
  • PR#2447 - Implementing new executor API (P0443)
  • IS#2439 - Implement executor proposal
  • IS#2408 - Stackoverflow detection for linux, e.g. based on libsigsegv
  • PR#2377 - Add a customization point for put_parcel so we can override actions
  • IS#2368 - HPX_ASSERT problem
  • IS#2324 - Change default number of threads used to the maximum of the system
  • IS#2266 - hpx_0.9.99 make tests fail
  • PR#2195 - Support for code completion in VIM
  • IS#2137 - Hpx does not compile over osx
  • IS#2092 - make tests should just build the tests
  • IS#2026 - Build HPX with Apple's clang
  • IS#1932 - hpx with PBS fails on multiple localities
  • PR#1914 - Parallel heap algorithm implementations WIP
  • IS#1598 - Disconnecting a locality results in segfault using heartbeat example
  • IS#1404 - unwrapped doesn't work with movable only types
  • IS#1400 - hpx::util::unwrapped doesn't work with non-future types
  • IS#1205 - TSS is broken
  • IS#1126 - vector<future<T> > does not work gracefully with dataflow, when_all and unwrapped
  • IS#1056 - Thread manager cleanup
  • IS#863 - Futures should not require a default constructor
  • IS#856 - Allow runtimemode_connect to be used with security enabled
  • IS#726 - Valgrind
  • IS#701 - Add RCR performance counter component
  • IS#528 - Add support for known failures and warning count/comparisons to hpx_run_tests.py
General Changes

Here are some of the main highlights and changes for this release (in no particular order):

  • Added the facility hpx::split_future which allows to convert a future<tuple<Ts...>> into a tuple<future<Ts>...>. This functionality is not available when compiling HPX with VS2012.
  • Added a new type of performance counter which allows to return a list of values for each invocation. We also added a first counter of this type which collects a histogram of the times between parcels being created.
  • Added new LCOs: hpx::lcos::channel and hpx::lcos::local::channel which are very similar to the well known channel constructs used in the Go language.
  • Added new performance counters reporting the amount of data handled by the networking layer on a action-by-action basis (please see PR#2289 for more details).
  • Added a new facility hpx::lcos::barrier, replacing the equally named older one. The new facility has a slightly changed API and is much more efficient. Most notable, the new facility exposes a (global) function hpx::lcos::barrier::synchronize() which represents a global barrier across all localities.
  • We have started to add support for vectorization to our parallel algorithm implementations. This support depends on using an external library, currently either Vc Library or Boost.SIMD. Please see IS#2333 for a list of currently supported algorithms. This is an experimental feature and its implementation and/or API might change in the future. Please see this blog-post for more information.
  • The parameter sequence for the hpx::parallel::transform_reduce overload taking one iterator range has changed to match the changes this algorithm has undergone while being moved to C++17. The old overload can be still enabled at configure time by specifying -DHPX_WITH_TRANSFORM_REDUCE_COMPATIBILITY=On to CMake.
  • The algorithm hpx::parallel::inner_product has been renamed to hpx::parallel::transform_reduce to match the changes this algorithm has undergone while being moved to C++17. The old inner_product names can be still enabled at configure time by specifying -DHPX_WITH_TRANSFORM_REDUCE_COMPATIBILITY=On to CMake.
  • Added versions of hpx::get_ptr taking client side representations for component instances as their parameter (instead of a global id).
  • Added the helper utility hpx::performance_counters::performance_counter_set helping to encapsulate a set of performance counters to be managed concurrently.
  • All execution policies and related classes have been renamed to be consistent with the naming changes applied for C++17. All policies now live in the namespace hpx::parallel::execution. The ols names can be still enabled at configure time by specifying -DHPX_WITH_EXECUTION_POLICY_COMPATIBILITY=On to CMake.
  • The thread scheduling subsystem has undergone a major refactoring which results in significant performance improvements. We have also imroved the performance of creating hpx::future and of various facilities handling those.
  • We have consolidated all of the code in HPX.Compute related to the integration of CUDA. hpx::partitioned_vector has been enabled to be usable with hpx::compute::vector which allows to place the partitions on one or more GPU devices.
  • Added new performance counters exposing various internals of the thread scheduling subsystem, such as the current idle- and busy-loop counters and instantaneous scheduler utilization.
  • Extended and improved the use of the ITTNotify hooks allowing to collect performance counter data and function annotation information from within the Intel Amplifier tool.
Breaking Changes
  • We have dropped support for the gcc compiler versions V4.6 and 4.7. The minimal gcc version we now test on is gcc V4.8.
  • We have removed (default) support for boost::chrono in interfaces, uses of it have been replaced with std::chrono. This facility can be still enabled at configure time by specifying -DHPX_WITH_BOOST_CHRONO_COMPATIBILITY=On to CMake.
  • The parameter sequence for the hpx::parallel::transform_reduce overload taking one iterator range has changed to match the changes this algorithm has undergone while being moved to C++17.
  • The algorithm hpx::parallel::inner_product has been renamed to hpx::parallel::transform_reduce to match the changes this algorithm has undergone while being moved to C++17.
  • the build options HPX_WITH_COLOCATED_BACKWARDS_COMPATIBILITY and HPX_WITH_COMPONENT_GET_GID_COMPATIBILITY are now disabled by default. Please change your code still depending on the deprecated interfaces.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • PR#2596 - Adding apex data
  • PR#2595 - Remove obsolete file
  • IS#2594 - FindOpenCL.cmake mismatch with the official cmake module
  • PR#2592 - First attempt to introduce spmd_block in hpx
  • IS#2591 - Feature request: continuation (then) which does not require the callable object to take a future<R> as parameter
  • PR#2588 - Daint fixes
  • PR#2587 - Fixing transfer_(continuation)_action::schedule
  • PR#2585 - Work around MSVC having an ICE when compiling with -Ob2
  • PR#2583 - chaning 7zip command to 7za in roll_release.sh
  • PR#2582 - First attempt to introduce spmd_block in hpx
  • PR#2581 - Enable annotated function for parallel algorithms
  • PR#2580 - First attempt to introduce spmd_block in hpx
  • PR#2579 - Make thread NICE level setting an option
  • PR#2578 - Implementing enqueue instead of busy wait when no sender is available
  • PR#2577 - Retrieve -std=c++11 consistent nvcc flag
  • PR#2576 - Add missing dependencies of cuda based tests
  • PR#2575 - Remove warnings due to some captured variables
  • PR#2573 - Attempt to resolve resolve_locality
  • PR#2572 - Adding APEX hooks to background thread
  • PR#2571 - Pick up hpx.ignore_batch_env from config map
  • PR#2570 - Add commandline options --hpx:print-counters-locally
  • PR#2569 - Fix computeapi unit tests
  • PR#2567 - This adds another barrier::synchronize before registering performance counters
  • PR#2564 - Cray static toolchain support
  • PR#2563 - Fixed unhandled exception during startup
  • PR#2562 - Remove partitioned_vector.cu from build tree when nvcc is used
  • IS#2561 - octo-tiger crash with commit 6e921495ff6c26f125d62629cbaad0525f14f7ab
  • PR#2560 - Prevent -Wundef warnings on Vc version checks
  • PR#2559 - Allowing CUDA callback to set the future directly from an OS thread
  • PR#2558 - Remove warnings due to float precisions
  • PR#2557 - Removing bogus handling of compile flags for CUDA
  • PR#2556 - Fixing scan partitioner
  • PR#2554 - Add more diagnostics to error thrown from find_appropriate_destination
  • IS#2555 - No valid parcelport configured
  • PR#2553 - Add cmake cuda_arch option
  • PR#2552 - Remove incomplete datapar bindings to libflatarray
  • PR#2551 - Rename hwloc_topology to hwloc_topology_info
  • PR#2550 - Apex api updates
  • PR#2549 - Pre-include defines.hpp to get the macro HPX_HAVE_CUDA value
  • PR#2548 - Fixing issue with disconnect
  • PR#2546 - Some fixes around cuda clang partitioned_vector example
  • PR#2545 - Fix uses of the Vc2 datapar flags; the value, not the type, should be passed to functions
  • PR#2542 - Make HPX_WITH_MALLOC easier to use
  • PR#2541 - avoid recompiles when enabling/disabling examples
  • PR#2540 - Fixing usage of target_link_libraries()
  • PR#2539 - fix RPATH behaviour
  • IS#2538 - HPX_WITH_CUDA corrupts compilation flags
  • PR#2537 - Add output of a Bazel Skylark extension for paths and compile options
  • PR#2536 - Add counter exposing total available memory to Windows as well
  • PR#2535 - Remove obsolete support for security
  • IS#2534 - Remove command line option --hpx:run-agas-server
  • PR#2533 - Pre-cache locality endpoints during bootstrap
  • PR#2532 - Fixing handling of GIDs during serialization preprocessing
  • PR#2531 - Amend uses of the term "functor"
  • PR#2529 - added counter for reading available memory
  • PR#2527 - Facilities to create actions from lambdas
  • PR#2526 - Updated docs: HPX_WITH_EXAMPLES
  • PR#2525 - Remove warnings related to unused captured variables
  • IS#2524 - CMAKE failed because it is missing: TCMALLOC_LIBRARY TCMALLOC_INCLUDE_DIR
  • PR#2523 - Fixing compose_cb stack overflow
  • PR#2522 - Instead of unlocking, ignore the lock while creating the message handler
  • PR#2521 - Create LPROGRESS_ logging macro to simplify progress tracking and timings
  • PR#2520 - Intel 17 support
  • PR#2519 - Fix components example
  • PR#2518 - Fixing parcel scheduling
  • IS#2517 - Race condition during Parcel Coalescing Handler creation
  • IS#2516 - HPX locks up when using at least 256 localities
  • IS#2515 - error: Install cannot find "/lib/hpx/libparcel_coalescing.so.0.9.99" but I can see that file
  • PR#2514 - Making sure that all continuations of a shared_future are invoked in order
  • PR#2513 - Fixing locks held during suspension
  • PR#2512 - MPI Parcelport improvements and fixes related to the background work changes
  • PR#2511 - Fixing bit-wise (zero-copy) serialization
  • IS#2509 - Linking errors in hwloc_topology
  • PR#2508 - Added documentation for debugging with core files
  • PR#2506 - Fixing background work invocations
  • PR#2505 - Fix tuple serialization
  • IS#2504 - Ensure continuations are called in the order they have been attached
  • PR#2503 - Adding serialization support for Vc v2 (datapar)
  • PR#2502 - Resolve various, minor compiler warnings
  • PR#2501 - Some other fixes around cuda examples
  • IS#2500 - nvcc / cuda clang issue due to a missing -DHPX_WITH_CUDA flag
  • PR#2499 - Adding support for std::array to wait_all and friends
  • PR#2498 - Execute background work as HPX thread
  • PR#2497 - Fixing configuration options for spinlock-deadlock detection
  • PR#2496 - Accounting for different compilers in CrayKNL toolchain file
  • PR#2494 - Adding component base class which ties a component instance to a given executor
  • PR#2493 - Enable controlling amount of pending threads which must be available to allow thread stealing
  • PR#2492 - Adding new command line option --hpx:print-counter-reset
  • PR#2491 - Resolve ambiguities when compiling with APEX
  • PR#2490 - Resuming threads waiting on future with higher priority
  • IS#2489 - nvcc issue because -std=c++11 appears twice
  • PR#2488 - Adding performance counters exposing the internal idle and busy-loop counters
  • PR#2487 - Allowing for plain suspend to reschedule thread right away
  • PR#2486 - Only flag HPX code for CUDA if HPX_WITH_CUDA is set
  • PR#2485 - Making thread-queue parameters runtime-configurable
  • PR#2484 - Added atomic counter for parcel-destinations
  • PR#2483 - Added priority-queue lifo scheduler
  • PR#2482 - Changing scheduler to steal only if more than a minimal number of tasks are available
  • PR#2481 - Extending command line option --hpx:print-counter-destination to support value 'none'
  • PR#2479 - Added option to disable signal handler
  • PR#2478 - Making sure the sine performance counter module gets loaded only for the corresponding example
  • IS#2477 - Breaking at a throw statement
  • PR#2476 - Annotated function
  • PR#2475 - Ensure that using %osthread% during logging will not throw for non-hpx threads
  • PR#2474 - Remove now superficial non_direct actions from base_lco and friends
  • PR#2473 - Refining support for ITTNotify
  • PR#2472 - Some fixes around hpx compute
  • IS#2470 - redefinition of boost::detail::spinlock
  • IS#2469 - Dataflow performance issue
  • PR#2468 - Perf docs update
  • PR#2466 - Guarantee to execute remote direct actions on HPX-thread
  • PR#2465 - Improve demo : Async copy and fixed device handling
  • PR#2464 - Adding performance counter exposing instantaneous scheduler utilization
  • PR#2463 - Downcast to future<void>
  • PR#2462 - Fixed usage of ITT-Notify API with Intel Amplifier
  • PR#2461 - Cublas demo
  • PR#2460 - Fixing thread bindings
  • PR#2459 - Make -std=c++11 nvcc flag consistent for in-build and installed versions
  • IS#2457 - Segmentation fault when registering a partitioned vector
  • PR#2452 - Properly releasing global barrier for unhandled exceptions
  • PR#2451 - Fixing long shutdown times
  • PR#2450 - Attempting to fix initialization errors on newer platforms (Boost V1.63)
  • PR#2449 - Replace BOOST_COMPILER_FENCE with an HPX version
  • PR#2448 - This fixes a possible race in the migration code
  • PR#2445 - Fixing dataflow et.al. for futures or future-ranges wrapped into ref()
  • PR#2444 - Fix segfaults
  • PR#2443 - Issue 2442
  • IS#2442 - Mismatch between #if/#endif and namespace scope brackets in this_thread_executers.hpp
  • IS#2441 - undeclared identifier BOOST_COMPILER_FENCE
  • PR#2440 - Knl build
  • PR#2438 - Datapar backend
  • PR#2437 - Adapt algorithm parameter sequence changes from C++17
  • PR#2436 - Adapt execution policy name changes from C++17
  • IS#2435 - Trunk broken, undefined reference to hpx::thread::interrupt(hpx::thread::id, bool)
  • PR#2434 - More fixes to resource manager
  • PR#2433 - Added versions of hpx::get_ptr taking client side representations
  • PR#2432 - Warning fixes
  • PR#2431 - Adding facility representing set of performance counters
  • PR#2430 - Fix parallel_executor thread spawning
  • PR#2429 - Fix attribute warning for gcc
  • IS#2427 - Seg fault running octo-tiger with latest HPX commit
  • IS#2426 - Bug in 9592f5c0bc29806fce0dbe73f35b6ca7e027edcb causes immediate crash in Octo-tiger
  • PR#2425 - Fix nvcc errors due to constexpr specifier
  • IS#2424 - Async action on component present on hpx::find_here is executing synchronously
  • PR#2423 - Fix nvcc errors due to constexpr specifier
  • PR#2422 - Implementing hpx::this_thread thread data functions
  • PR#2421 - Adding benchmark for wait_all
  • IS#2420 - Returning object of a component client from another component action fails
  • PR#2419 - Infiniband parcelport
  • IS#2418 - gcc + nvcc fails to compile code that uses partitioned_vector
  • PR#2417 - Fixing context switching
  • PR#2416 - Adding fixes and workarounds to allow compilation with nvcc/msvc (VS2015up3)
  • PR#2415 - Fix errors coming from hpx compute examples
  • PR#2414 - Fixing msvc12
  • PR#2413 - Enable cuda/nvcc or cuda/clang when using add_hpx_executable()
  • PR#2412 - Fix issue in HPX_SetupTarget.cmake when cuda is used
  • PR#2411 - This fixes the core compilation issues with MSVC12
  • IS#2410 - undefined reference to opal_hwloc191_hwloc_.....
  • PR#2409 - Fixing locking for channel and receive_buffer
  • PR#2407 - Solving #2402 and #2403
  • PR#2406 - Improve guards
  • PR#2405 - Enable parallel::for_each for iterators returning proxy types
  • PR#2404 - Forward the explicitly given result_type in the hpx invoke
  • IS#2403 - datapar_execution + zip iterator: lambda arguments aren't references
  • IS#2402 - datapar algorithm instantiated with wrong type #2402
  • PR#2401 - Added support for imported libraries to HPX_Libraries.cmake
  • PR#2400 - Use CMake policy CMP0060
  • IS#2399 - Error trying to push back vector of futures to vector
  • PR#2398 - Allow config #defines to be written out to custom config/defines.hpp
  • IS#2397 - CMake generated config defines can cause tedious rebuilds category
  • IS#2396 - BOOST_ROOT paths are not used at link time
  • PR#2395 - Fix target_link_libraries() issue when HPX Cuda is enabled
  • IS#2394 - Template compilation error using HPX_WITH_DATAPAR_LIBFLATARRAY
  • PR#2393 - Fixing lock registration for recursive mutex
  • PR#2392 - Add keywords in target_link_libraries in hpx_setup_target
  • PR#2391 - Clang goroutines
  • IS#2390 - Adapt execution policy name changes from C++17
  • PR#2389 - Chunk allocator and pool are not used and are obsolete
  • PR#2388 - Adding functionalities to datapar needed by octotiger
  • PR#2387 - Fixing race condition for early parcels
  • IS#2386 - Lock registration broken for recursive_mutex
  • PR#2385 - Datapar zip iterator
  • PR#2384 - Fixing race condition in for_loop_reduction
  • PR#2383 - Continuations
  • PR#2382 - add LibFlatArray-based backend for datapar
  • PR#2381 - remove unused typedef to get rid of compiler warnings
  • PR#2380 - Tau cleanup
  • PR#2379 - Can send immediate
  • PR#2378 - Renaming copy_helper/copy_n_helper/move_helper/move_n_helper
  • IS#2376 - Boost trunk's spinlock initializer fails to compile
  • PR#2375 - Add support for minimal thread local data
  • PR#2374 - Adding API functions set_config_entry_callback
  • PR#2373 - Add a simple utility for debugging that gives supended task backtraces
  • PR#2372 - Barrier Fixes
  • IS#2370 - Can't wait on a wrapped future
  • PR#2369 - Fixing stable_partition
  • PR#2367 - Fixing find_prefixes for Windows platforms
  • PR#2366 - Testing for experimental/optional only in C++14 mode
  • PR#2364 - Adding set_config_entry
  • PR#2363 - Fix papi
  • PR#2362 - Adding missing macros for new non-direct actions
  • PR#2361 - Improve cmake output to help debug compiler incompatibility check
  • PR#2360 - Fixing race condition in condition_variable
  • PR#2359 - Fixing shutdown when parcels are still in flight
  • IS#2357 - failed to insert console_print_action into typename_to_id_t registry
  • PR#2356 - Fixing return type of get_iterator_tuple
  • PR#2355 - Fixing compilation against Boost 1 62
  • PR#2354 - Adding serialization for mask_type if CPU_COUNT > 64
  • PR#2353 - Adding hooks to tie in APEX into the parcel layer
  • IS#2352 - Compile errors when using intel 17 beta (for KNL) on edison
  • PR#2351 - Fix function vtable get_function_address implementation
  • IS#2350 - Build failure - master branch (4de09f5) with Intel Compiler v17
  • PR#2349 - Enabling zero-copy serialization support for std::vector<>
  • PR#2348 - Adding test to verify #2334 is fixed
  • PR#2347 - Bug fixes for hpx.compute and hpx::lcos::channel
  • PR#2346 - Removing cmake "find" files that are in the APEX cmake Modules
  • PR#2345 - Implemented parallel::stable_partition
  • PR#2344 - Making hpx::lcos::channel usable with basename registration
  • PR#2343 - Fix a couple of examples that failed to compile after recent api changes
  • IS#2342 - Enabling APEX causes link errors
  • PR#2341 - Removing cmake "find" files that are in the APEX cmake Modules
  • PR#2340 - Implemented all existing datapar algorithms using Boost.SIMD
  • PR#2339 - Fixing 2338
  • PR#2338 - Possible race in sliding semaphore
  • PR#2337 - Adjust osu_latency test to measure window_size parcels in flight at once
  • PR#2336 - Allowing remote direct actions to be executed without spawning a task
  • PR#2335 - Making sure multiple components are properly initialized from arguments
  • IS#2334 - Cannot construct component with large vector on a remote locality
  • PR#2332 - Fixing hpx::lcos::local::barrier
  • PR#2331 - Updating APEX support to include OTF2
  • PR#2330 - Support for data-parallelism for parallel algorithms
  • IS#2329 - Coordinate settings in cmake
  • PR#2328 - fix LibGeoDecomp builds with HPX + GCC 5.3.0 + CUDA 8RC
  • PR#2326 - Making scan_partitioner work (for now)
  • IS#2323 - Constructing a vector of components only correctly initializes the first component
  • PR#2322 - Fix problems that bubbled up after merging #2278
  • PR#2321 - Scalable barrier
  • PR#2320 - Std flag fixes
  • IS#2319 - -std=c++14 and -std=c++1y with Intel can't build recent Boost builds due to insufficient C++14 support; don't enable these flags by default for Intel
  • PR#2318 - Improve handling of --hpx:bind=<bind-spec>
  • PR#2317 - Making sure command line warnings are printed once only
  • PR#2316 - Fixing command line handling for default bind mode
  • PR#2315 - Set id_retrieved if set_id is present
  • IS#2314 - Warning for requested/allocated thread discrepancy is printed twice
  • IS#2313 - --hpx:print-bind doesn't work with --hpx:pu-step
  • IS#2312 - --hpx:bind range specifier restrictions are overly restrictive
  • IS#2311 - hpx_0.9.99 out of project build fails
  • PR#2310 - Simplify function registration
  • PR#2309 - Spelling and grammar revisions in documentation (and some code)
  • PR#2306 - Correct minor typo in the documentation
  • PR#2305 - Cleaning up and fixing parcel coalescing
  • PR#2304 - Inspect checks for stream related includes
  • PR#2303 - Add functionality allowing to enumerate threads of given state
  • PR#2301 - Algorithm overloads fix for VS2013
  • PR#2300 - Use <cstdint>, add inspect checks
  • PR#2299 - Replace boost::[c]ref with std::[c]ref, add inspect checks
  • PR#2297 - Fixing compilation with no hw_loc
  • PR#2296 - Hpx compute
  • PR#2295 - Making sure for_loop(execution::par, 0, N, ...) is actually executed in parallel
  • PR#2294 - Throwing exceptions if the runtime is not up and running
  • PR#2293 - Removing unused parcel port code
  • PR#2292 - Refactor function vtables
  • PR#2291 - Fixing 2286
  • PR#2290 - Simplify algorithm overloads
  • PR#2289 - Adding performance counters reporting parcel related data on a per-action basis
  • IS#2288 - Remove dormant parcelports
  • IS#2286 - adjustments to parcel handling to support parcelports that do not need a connection cache
  • PR#2285 - add CMake option to disable package export
  • PR#2283 - Add more inspect checks for use of deprecated components
  • IS#2282 - Arithmetic exception in executor static chunker
  • IS#2281 - For loop doesn't parallelize
  • PR#2280 - Fixing 2277: build failure with PAPI
  • PR#2279 - Child vs parent stealing
  • IS#2277 - master branch build failure (53c5b4f) with papi
  • PR#2276 - Compile time launch policies
  • PR#2275 - Replace boost::chrono with std::chrono in interfaces
  • PR#2274 - Replace most uses of Boost.Assign with initializer list
  • PR#2273 - Fixed typos
  • PR#2272 - Inspect checks
  • PR#2270 - Adding test verifying -Ihpx.os_threads=all
  • PR#2269 - Added inspect check for now obsolete boost type traits
  • PR#2268 - Moving more code into source files
  • IS#2267 - Add inspect support to deprecate Boost.TypeTraits
  • PR#2265 - Adding channel LCO
  • PR#2264 - Make support for std::ref mandatory
  • PR#2263 - Constrain tuple_member forwarding constructor
  • IS#2262 - Test hpx.os_threads=all
  • IS#2261 - OS X: Error: no matching constructor for initialization of 'hpx::lcos::local::condition_variable_any'
  • IS#2260 - Make support for std::ref mandatory
  • PR#2259 - Remove most of Boost.MPL, Boost.EnableIf and Boost.TypeTraits
  • PR#2258 - Fixing #2256
  • PR#2257 - Fixing launch process
  • IS#2256 - Actions are not registered if not invoked
  • PR#2255 - Coalescing histogram
  • PR#2254 - Silence explicit initialization in copy-constructor warnings
  • PR#2253 - Drop support for GCC 4.6 and 4.7
  • PR#2252 - Prepare V1.0
  • PR#2251 - Convert to 0.9.99
  • PR#2249 - Adding iterator_facade and iterator_adaptor
  • IS#2248 - Need a feature to yield to a new task immediately
  • PR#2246 - Adding split_future
  • PR#2245 - Add an example for handing over a component instance to a dynamically launched locality
  • IS#2243 - Add example demonstrating AGAS symbolic name registration
  • IS#2242 - pkgconfig test broken on CentOS 7 / Boost 1.61
  • IS#2241 - Compilation error for partitioned vector in hpx_compute branch
  • PR#2240 - Fixing termination detection on one locality
  • IS#2239 - Create a new facility lcos::split_all
  • IS#2236 - hpx::cout vs. std::cout
  • PR#2232 - Implement local-only primary namespace service
  • IS#2147 - would like to know how much data is being routed by particular actions
  • IS#2109 - Warning while compiling hpx
  • IS#1973 - Setting INTERFACE_COMPILE_OPTIONS for hpx_init in CMake taints Fortran_FLAGS
  • IS#1864 - run_guarded using bound function ignores reference
  • IS#1754 - Running with TCP parcelport causes immediate crash or freeze
  • IS#1655 - Enable zip_iterator to be used with Boost traversal iterator categories
  • IS#1591 - Optimize AGAS for shared memory only operation
  • IS#1401 - Need an efficient infiniband parcelport
  • IS#1125 - Fix the IPC parcelport
  • IS#839 - Refactor ibverbs and shmem parcelport
  • IS#702 - Add instrumentation of parcel layer
  • IS#668 - Implement ispc task interface
  • IS#533 - Thread queue/deque internal parameters should be runtime configurable
  • IS#475 - Create a means of combining performance counters into querysets
General Changes

As the version number of this release hints, we consider this release to be a preview for the upcoming HPX V1.0. All of the functionalities we set out to implement for V1.0 are in place; all of the features we wanted to have exposed are ready. We are very happy with the stability and performance of HPX and we would like to present this release to the community in order for us to gather broad feedback before releasing V1.0. We still expect for some minor details to change, but on the whole this release represents what we would like to have in a V1.0.

Overall, since the last release we have had almost 1600 commits while closing almost 400 tickets. These numbers reflect the incredible development activity we have seen over the last couple of months. We would like to express a big 'Thank you!' to all contributors and those who helped to make this release happen.

The most notable addition in terms of new functionality available with this release is the full implementation of object migration (i.e. the ability to transparently move HPX components to a different compute node). Additionally, this release of HPX cleans up many minor issues and some API inconsistencies.

Here are some of the main highlights and changes for this release (in no particular order):

  • We have fixed a couple of issues in AGAS and the parcel layer which have caused hangs, segmentation faults at exit, and a slowdown of applications over time. Fixing those has significantly increased the overall stability and performance of distributed runs.
  • We have started to add parallel algorithm overloads based on the C++ Extensions for Ranges (N4560) proposal. This also includes the addition of projections to the existing algorithms. Please see IS#1668 for a list of algorithms which have been adapted to N4560.
  • We have implemented index-based parallel for-loops based on a corresponding standardization proposal (P0075R1). Please see IS#2016 for a list of available algorithms.
  • We have added implementations for more parallel algorithms as proposed for the upcoming C++ 17 Standard. See IS#1141 for an overview of which algorithms are available by now.
  • We have started to implement a new prototypical functionality with HPX.Compute which uniformly exposes some of the higher level APIs to heterogeneous architectures (currently CUDA). This functionality is an early preview and should not be considered stable. It may change considerably in the future.
  • We have pervasively added (optional) executor arguments to all API functions which schedule new work. Executors are now used throughout the code base as the main means of executing tasks.
  • Added hpx::make_future<R>(future<T> &&) allowing to convert a future of any type T into a future of any other type R, either based on default conversion rules of the embedded types or using a given explicit conversion function.
  • We finally finished the implementation of transparent migration of components to another locality. It is now possible to trigger a migration operation without 'stopping the world' for the object to migrate. HPX will make sure that no work is being performed on an object before it is migrated and that all subsequently scheduled work for the migrated object will be transparently forwarded to the new locality. Please note that the global id of the migrated object does not change, thus the application will not have to be changed in any way to support this new functionality. Please note that this feature is currently considered experimental. See IS#559 and PR#1966 for more details.
  • The hpx::dataflow facility is now usable with actions. Similarly to hpx::async, actions can be specified as an explicit template argument (hpx::dataflow<Action>(target, ...)) or as the first argument (hpx::dataflow(Action(), target, ...)). We have also enabled the use of distribution policies as the target for dataflow invocations. Please see IS#1265 and PR#1912 for more information.
  • Adding overloads of gather_here and gather_there to accept the plain values of the data to gather (in addition to the existing overloads expecting futures).
  • We have cleaned up and refactored large parts of the code base. This helped reducing compile and link times of HPX itself and also of applications depending on it. We have further decreased the dependency of HPX on the Boost libraries by replacing part of those with facilities available from the standard libraries.
  • Wherever possible we have removed dependencies of our API on Boost by replacing those with the equivalent facility from the C++11 standard library.
  • We have added new performance counters for parcel coalescing, file-IO, the AGAS cache, and overall scheduler time. Resetting performance counters has been overhauled and fixed.
  • We have introduced a generic client type hpx::components::client<> and added support for using it with hpx::async. This removes the necessity to implement specific client types for every component type without losing type safety. This deemphasizes the need for using the low level hpx::id_type for referencing (possibly remote) component instances. The plan is to deprecate the direct use of hpx::id_type in user code in the future.
  • We have added a special iterator which supports automatic prefetching of one or more arrays for speeding up loop-like code (see hpx::parallel::util::make_prefetcher_context()).
  • We have extended the interfaces exposed from executors (as proposed by N4406) to accept an arbitrary number of arguments.
Breaking Changes
  • In order to move the dataflow facility to namespace hpx we added a definition of hpx::dataflow which might create ambiguities in existing codes. The previous definition of this facility (hpx::lcos::local::dataflow) has been deprecated and is available only if the constant -DHPX_WITH_LOCAL_DATAFLOW_COMPATIBILITY=On to __cmake __ is defined at configuration time. Please explicitly qualify all uses of the dataflow facility if you enable this compatibility setting and encounter ambiguities.
  • The adaptation of the C++ Extensions for Ranges (N4560) proposal imposes some breaking changes related to the return types of some of the parallel algorithms. Please see IS#1668 for a list of algorithms which have already been adapted.
  • The facility hpx::lcos::make_future_void() has been replaced by hpx::make_future<void>().
  • We have removed support for Intel V13 and gcc 4.4.x.
  • We have removed (default) support for the generic hpx::parallel::execution_poliy because it was removed from the Parallelism TS (N4409) while it was being added to the upcoming C++17 Standard. This facility can be still enabled at configure time by specifying -DHPX_WITH_GENERIC_EXECUTION_POLICY=On to CMake.
  • Uses of boost::shared_ptr and related facilities have been replaced with std::shared_ptr and friends. Uses of boost::unique_lock, boost::lock_guard etc. have also been replaced by the equivalent (and equally named) tools available from the C++11 standard library.
  • Facilities that used to expect an explicit boost::unique_lock now take an std::unique_lock. Additionally, condition_variable no longer aliases condition_variable_any; its interface now only works with std::unique_lock<local::mutex>.
  • Uses of boost::function, boost::bind, boost::tuple have been replaced by the corresponding facilities in HPX (hpx::util::function, hpx::util::bind, and hpx::util::tuple, respectively).
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • PR#2250 - change default chunker of parallel executor to static one
  • PR#2247 - HPX on ppc64le
  • PR#2244 - Fixing MSVC problems
  • PR#2238 - Fixing small typos
  • PR#2237 - Fixing small typos
  • PR#2234 - Fix broken add test macro when extra args are passed in
  • PR#2231 - Fixing possible race during future awaiting in serialization
  • PR#2230 - Fix stream nvcc
  • PR#2229 - Fixed run_as_hpx_thread
  • PR#2228 - On prefetching_test branch : adding prefetching_iterator and related tests used for prefetching containers within lambda functions
  • PR#2227 - Support for HPXCL's opencl::event
  • PR#2226 - Preparing for release of V0.9.99
  • PR#2225 - fix issue when compiling components with hpxcxx
  • PR#2224 - Compute alloc fix
  • PR#2223 - Simplify promise
  • PR#2222 - Replace last uses of boost::function by util::function_nonser
  • PR#2221 - Fix config tests
  • PR#2220 - Fixing gcc 4.6 compilation issues
  • PR#2219 - nullptr support for [unique_]function
  • PR#2218 - Introducing clang tidy
  • PR#2216 - Replace NULL with nullptr
  • IS#2214 - Let inspect flag use of NULL, suggest nullptr instead
  • PR#2213 - Require support for nullptr
  • PR#2212 - Properly find jemalloc through pkg-config
  • PR#2211 - Disable a couple of warnings reported by Intel on Windows
  • PR#2210 - Fixed host::block_allocator::bulk_construct
  • PR#2209 - Started to clean up new sort algorithms, made things compile for sort_by_key
  • PR#2208 - A couple of fixes that were exposed by a new sort algorithm
  • PR#2207 - Adding missing includes in /hpx/include/serialization.hpp
  • PR#2206 - Call package_action::get_future before package_action::apply
  • PR#2205 - The indirect_packaged_task::operator() needs to be run on a HPX thread
  • PR#2204 - Variadic executor parameters
  • PR#2203 - Delay-initialize members of partitoned iterator
  • PR#2202 - Added segmented fill for hpx::vector
  • IS#2201 - Null Thread id encountered on partitioned_vector
  • PR#2200 - Fix hangs
  • PR#2199 - Deprecating hpx/traits.hpp
  • PR#2198 - Making explicit inclusion of external libraries into build
  • PR#2197 - Fix typo in QT CMakeLists
  • PR#2196 - Fixing a gcc warning about attributes being ignored
  • PR#2194 - Fixing partitioned_vector_spmd_foreach example
  • IS#2193 - partitioned_vector_spmd_foreach seg faults
  • PR#2192 - Support Boost.Thread v4
  • PR#2191 - HPX.Compute prototype
  • PR#2190 - Spawning operation on new thread if remaining stack space becomes too small
  • PR#2189 - Adding callback taking index and future to when_each
  • PR#2188 - Adding new example demonstrating receive_buffer
  • PR#2187 - Mask 128-bit ints if CUDA is being used
  • PR#2186 - Make startup & shutdown functions unique_function
  • PR#2185 - Fixing logging output not to cause hang on shutdown
  • PR#2184 - Allowing component clients as action return types
  • IS#2183 - Enabling logging output causes hang on shutdown
  • IS#2182 - 1d_stencil seg fault
  • IS#2181 - Setting small stack size does not change default
  • PR#2180 - Changing default bind mode to balanced
  • PR#2179 - adding prefetching_iterator and related tests used for prefetching containers within lambda functions
  • PR#2177 - Fixing 2176
  • IS#2176 - Launch process test fails on OSX
  • PR#2175 - Fix unbalanced config/warnings includes, add some new ones
  • PR#2174 - Fix test categorization : regression not unit
  • IS#2172 - Different performance results
  • IS#2171 - "negative entry in reference count table" running octotiger on 32 nodes on queenbee
  • IS#2170 - Error while compiling on Mac + boost 1.60
  • PR#2168 - Fixing problems with is_bitwise_serializable
  • IS#2167 - startup & shutdown function should accept unique_function
  • IS#2166 - Simple receive_buffer example
  • PR#2165 - Fix wait all
  • PR#2164 - Fix wait all
  • PR#2163 - Fix some typos in config tests
  • PR#2162 - Improve #includes
  • PR#2160 - Add inspect check for missing #include <list>
  • PR#2159 - Add missing finalize call to stop test hanging
  • PR#2158 - Algo fixes
  • PR#2157 - Stack check
  • IS#2156 - OSX reports stack space incorrectly (generic context coroutines)
  • IS#2155 - Race condition suspected in runtime
  • PR#2154 - Replace boost::detail::atomic_count with the new util::atomic_count
  • PR#2153 - Fix stack overflow on OSX
  • PR#2152 - Define is_bitwise_serializable as is_trivially_copyable when available
  • PR#2151 - Adding missing <cstring> for std::mem* functions
  • IS#2150 - Unable to use component clients as action return types
  • PR#2149 - std::memmove copies bytes, use bytes*sizeof(type) when copying larger types
  • PR#2146 - Adding customization point for parallel copy/move
  • PR#2145 - Applying changes to address warnings issued by latest version of PVS Studio
  • IS#2148 - hpx::parallel::copy is broken after trivially copyable changes
  • PR#2144 - Some minor tweaks to compute prototype
  • PR#2143 - Added Boost version support information over OSX platform
  • PR#2142 - Fixing memory leak in example
  • PR#2141 - Add missing specializations in execution policies
  • PR#2139 - This PR fixes a few problems reported by Clang's Undefined Behavior sanitizer
  • PR#2138 - Revert "Adding fedora docs"
  • PR#2136 - Removed double semicolon
  • PR#2135 - Add deprecated #include check for hpx_fwd.hpp
  • PR#2134 - Resolved memory leak in stencil_8
  • PR#2133 - Replace uses of boost pointer containers
  • PR#2132 - Removing unused typedef
  • PR#2131 - Add several include checks for std facilities
  • PR#2130 - Fixing parcel compression, adding test
  • PR#2129 - Fix invalid attribute warnings
  • IS#2128 - hpx::init seems to segfault
  • PR#2127 - Making executor_traits N-nary
  • PR#2126 - GCC 4.6 fails to deduce the correct type in lambda
  • PR#2125 - Making parcel coalescing test actually test something
  • IS#2124 - Make a testcase for parcel compression
  • IS#2123 - hpx/hpx/runtime/applier_fwd.hpp - Multiple defined types
  • IS#2122 - Exception in primary_namespace::resolve_free_list
  • IS#2121 - Possible memory leak in 1d_stencil_8
  • PR#2120 - Fixing 2119
  • IS#2119 - reduce_by_key compilation problems
  • IS#2118 - Premature unwrapping of boost::ref'ed arguments
  • PR#2117 - Added missing initializer on last constructor for thread_description
  • PR#2116 - Use a lightweight bind implementation when no placeholders are given
  • PR#2115 - Replace boost::shared_ptr with std::shared_ptr
  • PR#2114 - Adding hook functions for executor_parameter_traits supporting timers
  • IS#2113 - Compilation error with gcc version 4.9.3 (MacPorts gcc49 4.9.3_0)
  • PR#2112 - Replace uses of safe_bool with explicit operator bool
  • IS#2111 - Compilation error on QT example
  • IS#2110 - Compilation error when passing non-future argument to unwrapped continuation in dataflow
  • IS#2109 - Warning while compiling hpx
  • IS#2109 - Stack trace of last bug causing issues with octotiger
  • IS#2108 - Stack trace of last bug causing issues with octotiger
  • PR#2107 - Making sure that a missing parcel_coalescing module does not cause startup exceptions
  • PR#2106 - Stop using hpx_fwd.hpp
  • IS#2105 - coalescing plugin handler is not optional any more
  • IS#2104 - Make executor_traits N-nary
  • IS#2103 - Build error with octotiger and hpx commit e657426d
  • PR#2102 - Combining thread data storage
  • PR#2101 - Added repartition version of 1d stencil that uses any performance counter
  • PR#2100 - Drop obsolete TR1 result_of protocol
  • PR#2099 - Replace uses of boost::bind with util::bind
  • PR#2098 - Deprecated inspect checks
  • PR#2097 - Reduce by key, extends #1141
  • PR#2096 - Moving local cache from external to hpx/util
  • PR#2095 - Bump minimum required Boost to 1.50.0
  • PR#2094 - Add include checks for several Boost utilities
  • IS#2093 - /.../local_cache.hpp(89): error #303: explicit type is missing ("int" assumed)
  • PR#2091 - Fix for Raspberry pi build
  • PR#2090 - Fix storage size for util::function<>
  • PR#2089 - Fix #2088
  • IS#2088 - More verbose output from cmake configuration
  • PR#2087 - Making sure init_globally always executes hpx_main
  • IS#2086 - Race condition with recent HPX
  • PR#2085 - Adding #include checker
  • PR#2084 - Replace boost lock types with standard library ones
  • PR#2083 - Simplify packaged task
  • PR#2082 - Updating APEX version for testing
  • PR#2081 - Cleanup exception headers
  • PR#2080 - Make call_once variadic
  • IS#2079 - With GNU C++, line 85 of hpx/config/version.hpp causes link failure when linking application
  • IS#2078 - Simple test fails with _GLIBCXX_DEBUG defined
  • PR#2077 - Instantiate board in nqueen client
  • PR#2076 - Moving coalescing registration to TUs
  • PR#2075 - Fixed some documentation typos
  • PR#2074 - Adding flush-mode to message handler flush
  • PR#2073 - Fixing performance regression introduced lately
  • PR#2072 - Refactor local::condition_variable
  • PR#2071 - Timer based on boost::asio::deadline_timer
  • PR#2070 - Refactor tuple based functionality
  • PR#2069 - Fixed typos
  • IS#2068 - Seg fault with octotiger
  • PR#2067 - Algorithm cleanup
  • PR#2066 - Split credit fixes
  • PR#2064 - Fixed some typos in docs
  • PR#2063 - Adding example demonstrating template components
  • IS#2062 - Support component templates
  • PR#2061 - Replace some uses of lexical_cast<string> with C++11 std::to_string
  • PR#2060 - Replace uses of boost::noncopyable with HPX_NON_COPYABLE
  • PR#2059 - Adding missing for_loop algorithms
  • PR#2058 - Move several definitions to more appropriate headers
  • PR#2057 - Simplify assert_owns_lock and ignore_while_checking
  • PR#2056 - Replacing std::result_of with util::result_of
  • PR#2055 - Fix process launching/connecting back
  • PR#2054 - Add a forwarding coroutine header
  • PR#2053 - Replace uses of boost::unordered_map with std::unordered_map
  • PR#2052 - Rewrite tuple unwrap
  • PR#2050 - Replace uses of BOOST_SCOPED_ENUM with C++11 scoped enums
  • PR#2049 - Attempt to narrow down split_credit problem
  • PR#2048 - Fixing gcc startup hangs
  • PR#2047 - Fixing when_xxx and wait_xxx for MSVC12
  • PR#2046 - adding persistent_auto_chunk_size and related tests for for_each
  • PR#2045 - Fixing HPX_HAVE_THREAD_BACKTRACE_DEPTH build time configuration
  • PR#2044 - Adding missing service executor types
  • PR#2043 - Removing ambiguous definitions for is_future_range and future_range_traits
  • PR#2042 - Clarify that HPX builds can use (much) more than 2GB per process
  • PR#2041 - Changing future_iterator_traits to support pointers
  • IS#2040 - Improve documentation memory usage warning?
  • PR#2039 - Coroutine cleanup
  • PR#2038 - Fix cmake policy CMP0042 warning MACOSX_RPATH
  • PR#2037 - Avoid redundant specialization of [unique_]function_nonser
  • PR#2036 - nvcc dies with an internal error upon pushing/popping warnings inside templates
  • IS#2035 - Use a less restrictive iterator definition in hpx::lcos::detail::future_iterator_traits
  • PR#2034 - Fixing compilation error with thread queue wait time performance counter
  • IS#2033 - Compilation error when compiling with thread queue waittime performance counter
  • IS#2032 - Ambiguous template instantiation for is_future_range and future_range_traits.
  • PR#2031 - Don't restart timer on every incoming parcel
  • PR#2030 - Unify handling of execution policies in parallel algorithms
  • PR#2029 - Make pkg-config .pc files use .dylib on OSX
  • PR#2028 - Adding process component
  • PR#2027 - Making check for compiler compatibility independent on compiler path
  • PR#2025 - Fixing inspect tool
  • PR#2024 - Intel13 removal
  • PR#2023 - Fix errors related to older boost versions and parameter pack expansions in lambdas
  • IS#2022 - gmake fail: "No rule to make target /usr/lib46/libboost_context-mt.so"
  • PR#2021 - Added Sudoku example
  • IS#2020 - Make errors related to init_globally.cpp example while building HPX out of the box
  • PR#2019 - Fixed some compilation and cmake errors encountered in nqueen example
  • PR#2018 - For loop algorithms
  • PR#2017 - Non-recursive at_index implementation
  • IS#2016 - Add index-based for-loops
  • IS#2015 - Change default bind-mode to balanced
  • PR#2014 - Fixed dataflow if invoked action returns a future
  • PR#2013 - Fixing compilation issues with external example
  • PR#2012 - Added Sierpinski Triangle example
  • IS#2011 - Compilation error while running sample hello_world_component code
  • PR#2010 - Segmented move implemented for hpx::vector
  • IS#2009 - pkg-config order incorrect on 14.04 / GCC 4.8
  • IS#2008 - Compilation error in dataflow of action returning a future
  • PR#2007 - Adding new performance counter exposing overall scheduler time
  • PR#2006 - Function includes
  • PR#2005 - Adding an example demonstrating how to initialize HPX from a global object
  • PR#2004 - Fixing 2000
  • PR#2003 - Adding generation parameter to gather to enable using it more than once
  • PR#2002 - Turn on position independent code to solve link problem with hpx_init
  • IS#2001 - Gathering more than once segfaults
  • IS#2000 - Undefined reference to hpx::assertion_failed
  • IS#1999 - Seg fault in hpx::lcos::base_lco_with_value<*>::set_value_nonvirt() when running octo-tiger
  • PR#1998 - Detect unknown command line options
  • PR#1997 - Extending thread description
  • PR#1996 - Adding natvis files to solution (MSVC only)
  • IS#1995 - Command line handling does not produce error
  • PR#1994 - Possible missing include in test_utils.hpp
  • PR#1993 - Add missing LANGUAGES tag to a hpx_add_compile_flag_if_available() call in CMakeLists.txt
  • PR#1992 - Fixing shared_executor_test
  • PR#1991 - Making sure the winsock library is properly initialized
  • PR#1990 - Fixing bind_test placeholder ambiguity coming from boost-1.60
  • PR#1989 - Performance tuning
  • PR#1987 - Make configurable size of internal storage in util::function
  • PR#1986 - AGAS Refactoring+1753 Cache mods
  • PR#1985 - Adding missing task_block::run() overload taking an executor
  • PR#1984 - Adding an optimized LRU Cache implementation (for AGAS)
  • PR#1983 - Avoid invoking migration table look up for all objects
  • PR#1981 - Replacing uintptr_t (which is not defined everywhere) with std::size_t
  • PR#1980 - Optimizing LCO continuations
  • PR#1979 - Fixing Cori
  • PR#1978 - Fix test check that got broken in hasty fix to memory overflow
  • PR#1977 - Refactor action traits
  • PR#1976 - Fixes typo in README.rst
  • PR#1975 - Reduce size of benchmark timing arrays to fix test failures
  • PR#1974 - Add action to update data owned by the partitioned_vector component
  • PR#1972 - Adding partitioned_vector SPMD example
  • PR#1971 - Fixing 1965
  • PR#1970 - Papi fixes
  • PR#1969 - Fixing continuation recursions to not depend on fixed amount of recursions
  • PR#1968 - More segmented algorithms
  • IS#1967 - Simplify component implementations
  • PR#1966 - Migrate components
  • IS#1964 - fatal error: 'boost/lockfree/detail/branch_hints.hpp' file not found
  • IS#1962 - parallel:copy_if has race condition when used on in place arrays
  • PR#1963 - Fixing Static Parcelport initialization
  • PR#1961 - Fix function target
  • IS#1960 - Papi counters don't reset
  • PR#1959 - Fixing 1958
  • IS#1958 - inclusive_scan gives incorrect results with non-commutative operator
  • PR#1957 - Fixing #1950
  • PR#1956 - Sort by key example
  • PR#1955 - Adding regression test for #1946: Hang in wait_all() in distributed run
  • IS#1954 - HPX releases should not use -Werror
  • PR#1953 - Adding performance analysis for AGAS cache
  • PR#1952 - Adapting test for explicit variadics to fail for gcc 4.6
  • PR#1951 - Fixing memory leak
  • IS#1950 - Simplify external builds
  • PR#1949 - Fixing yet another lock that is being held during suspension
  • PR#1948 - Fixed container algorithms for Intel
  • PR#1947 - Adding workaround for tagged_tuple
  • IS#1946 - Hang in wait_all() in distributed run
  • PR#1945 - Fixed container algorithm tests
  • IS#1944 - assertion 'p.destination_locality() == hpx::get_locality()' failed
  • PR#1943 - Fix a couple of compile errors with clang
  • PR#1942 - Making parcel coalescing functional
  • IS#1941 - Re-enable parcel coalescing
  • PR#1940 - Touching up make_future
  • PR#1939 - Fixing problems in over-subscription management in the resource manager
  • PR#1938 - Removing use of unified Boost.Thread header
  • PR#1937 - Cleaning up the use of Boost.Accumulator headers
  • PR#1936 - Making sure interval timer is started for aggregating performance counters
  • PR#1935 - Tagged results
  • PR#1934 - Fix remote async with deferred launch policy
  • IS#1933 - Floating point exception in statistics_counter<boost::accumulators::tag::mean>::get_counter_value
  • PR#1932 - Removing superfluous includes of boost/lockfree/detail/branch_hints.hpp
  • PR#1931 - fix compilation with clang 3.8.0
  • IS#1930 - Missing online documentation for HPX 0.9.11
  • PR#1929 - LWG2485: get() should be overloaded for const tuple&&
  • PR#1928 - Revert "Using ninja for circle-ci builds"
  • PR#1927 - Using ninja for circle-ci builds
  • PR#1926 - Fixing serialization of std::array
  • IS#1925 - Issues with static HPX libraries
  • IS#1924 - Peformance degrading over time
  • IS#1923 - serialization of std::array appears broken in latest commit
  • PR#1922 - Container algorithms
  • PR#1921 - Tons of smaller quality improvements
  • IS#1920 - Seg fault in hpx::serialization::output_archive::add_gid when running octotiger
  • IS#1919 - Intel 15 compiler bug preventing HPX build
  • PR#1918 - Address sanitizer fixes
  • PR#1917 - Fixing compilation problems of parallel::sort with Intel compilers
  • PR#1916 - Making sure code compiles if HPX_WITH_HWLOC=Off
  • IS#1915 - max_cores undefined if HPX_WITH_HWLOC=Off
  • PR#1913 - Add utility member functions for partitioned_vector
  • PR#1912 - Adding support for invoking actions to dataflow
  • PR#1911 - Adding first batch of container algorithms
  • PR#1910 - Keep cmake_module_path
  • PR#1909 - Fix mpirun with pbs
  • PR#1908 - Changing parallel::sort to return the last iterator as proposed by N4560
  • PR#1907 - Adding a minimum version for Open MPI
  • PR#1906 - Updates to the Release Procedure
  • PR#1905 - Fixing #1903
  • PR#1904 - Making sure std containers are cleared before serialization loads data
  • IS#1903 - When running octotiger, I get: assertion '(*new_gids_)[gid].size() == 1' failed: HPX(assertion_failure)
  • IS#1902 - Immediate crash when running hpx/octotiger with _GLIBCXX_DEBUG defined.
  • PR#1901 - Making non-serializable classes non-serializable
  • IS#1900 - Two possible issues with std::list serialization
  • PR#1899 - Fixing a problem with credit splitting as revealed by #1898
  • IS#1898 - Accessing component from locality where it was not created segfaults
  • PR#1897 - Changing parallel::sort to return the last iterator as proposed by N4560
  • IS#1896 - version 1.0?
  • IS#1895 - Warning comment on numa_allocator is not very clear
  • PR#1894 - Add support for compilers that have thread_local
  • PR#1893 - Fixing 1890
  • PR#1892 - Adds typed future_type for executor_traits
  • PR#1891 - Fix wording in certain parallel algorithm docs
  • IS#1890 - Invoking papi counters give segfault
  • PR#1889 - Fixing problems as reported by clang-check
  • PR#1888 - WIP parallel is_heap
  • PR#1887 - Fixed resetting performance counters related to idle-rate, etc
  • IS#1886 - Run hpx with qsub does not work
  • PR#1885 - Warning cleaning pass
  • PR#1884 - Add missing parallel algorithm header
  • PR#1883 - Add feature test for thread_local on Clang for TLS
  • PR#1882 - Fix some redundant qualifiers
  • IS#1881 - Unable to compile Octotiger using HPX and Intel MPI on SuperMIC
  • IS#1880 - clang with libc++ on Linux needs TLS case
  • PR#1879 - Doc fixes for #1868
  • PR#1878 - Simplify functions
  • PR#1877 - Removing most usage of Boost.Config
  • PR#1876 - Add missing parallel algorithms to algorithm.hpp
  • PR#1875 - Simplify callables
  • PR#1874 - Address long standing FIXME on using std::unique_ptr with incomplete types
  • PR#1873 - Fixing 1871
  • PR#1872 - Making sure PBS environment uses specified node list even if no PBS_NODEFILE env is available
  • IS#1871 - Fortran checks should be optional
  • PR#1870 - Touch local::mutex
  • PR#1869 - Documentation refactoring based off #1868
  • PR#1867 - Embrace static_assert
  • PR#1866 - Fix #1803 with documentation refactoring
  • PR#1865 - Setting OUTPUT_NAME as target properties
  • PR#1863 - Use SYSTEM for boost includes
  • PR#1862 - Minor cleanups
  • PR#1861 - Minor Corrections for Release
  • PR#1860 - Fixing hpx gdb script
  • IS#1859 - reset_active_counters resets times and thread counts before some of the counters are evaluated
  • PR#1858 - Release V0.9.11
  • PR#1857 - removing diskperf example from 9.11 release
  • PR#1856 - fix return in packaged_task_base::reset()
  • IS#1842 - Install error: file INSTALL cannot find libhpx_parcel_coalescing.so.0.9.11
  • PR#1839 - Adding fedora docs
  • PR#1824 - Changing version on master to V0.9.12
  • PR#1818 - Fixing #1748
  • IS#1815 - seg fault in AGAS
  • IS#1803 - wait_all documentation
  • IS#1796 - Outdated documentation to be revised
  • IS#1759 - glibc munmap_chunk or free(): invalid pointer on SuperMIC
  • IS#1753 - HPX performance degrades with time since execution begins
  • IS#1748 - All public HPX headers need to be self contained
  • PR#1719 - How to build HPX with Visual Studio
  • IS#1684 - Race condition when using --hpx:connect?
  • PR#1658 - Add serialization for std::set (as there is for std::vector and std::map)
  • PR#1641 - Generic client
  • IS#1632 - heartbeat example fails on separate nodes
  • PR#1603 - Adds preferred namespace check to inspect tool
  • IS#1559 - Extend inspect tool
  • IS#1523 - Remote async with deferred launch policy never executes
  • IS#1472 - Serialization issues
  • IS#1457 - Implement N4392: C++ Latches and Barriers
  • PR#1444 - Enabling usage of moveonly types for component construction
  • IS#1407 - The Intel 13 compiler has failing unit tests
  • IS#1405 - Allow component constructors to take movable only types
  • IS#1265 - Enable dataflow() to be usable with actions
  • IS#1236 - NUMA aware allocators
  • IS#802 - Fix Broken Examples
  • IS#559 - Add hpx::migrate facility
  • IS#449 - Make actions with template arguments usable and add documentation
  • IS#279 - Refactor addressing_service into a base class and two derived classes
  • IS#224 - Changing thread state metadata is not thread safe
  • IS#55 - Uniform syntax for enums should be implemented

Our main focus for this release was the design and development of a coherent set of higher-level APIs exposing various types of parallelism to the application programmer. We introduced the concepts of an executor, which can be used to customize the where and when of execution of tasks in the context of parallelizing codes. We extended all APIs related to managing parallel tasks to support executors which gives the user the choce of either using one of the predefined executor types or to provide its own, possibly application specific, executor. We paid very close attention to align all of these changes with the existing C++ Standards documents or with the ongoing proposals for standardization.

This release is the first after our change to a new development policy. We switched all development to be strictly performed on branches only, all direct commits to our main branch (master) are prohibited. Any change has to go through a peer review before it will be merged to master. As a result the overall stability of our code base has significantly increased, the development process itself has been simplified. This change manifests itself in a large number of pull-requests which have been merged (please see below for a full list of closed issues and pull-requests). All in all for this release, we closed almost 100 issues and merged over 290 pull-requests. There have been over 1600 commits to the master branch since the last release.

General Changes
  • We are moving into the direction of unifying managed and simple components. As such, the classes hpx::components::component and hpx::components::component_base have been added which currently just forward to the currently existing simple component facilities. The examples have been converted to only use those two classes.
  • Added integration with the CircleCI hosted continuous integration service. This gives us constant and immediate feedback on the health of our master branch.
  • The compiler configuration subsystem in the build system has been reimplemented. Instead of using Boost.Config we now use our own lightweight set of cmake scripts to determine the available language and library features supported by the used compiler.
  • The API for creating instances of components has been consolidated. All component instances should be created using the hpx::new_<>() only. It allows to instantiate both, single component instances and multiple component instances. The placement of the created components can be controlled by special distribution policies. Please see the corresponding documentation outlining the use of hpx::new_<>().
  • Introduced four new distribution policies which can be used with many API functions which traditionally expected to be used with a locality id. The new distribution policies are:
  • The new distribution policies can now be also used with hpx::async. This change also deprecates hpx::async_colocated(id, ...) which now is replaced by a distribution policy: hpx::async(hpx::colocated(id), ...).
  • The hpx::vector and hpx::unordered_map data structures can now be used with the new distribution policies as well.
  • The parallel facility hpx::parallel::task_region has been renamed to hpx::parallel::task_block based on the changes in the corresponding standardization proposal N4411.
  • Added extensions to the parallel facility hpx::parallel::task_block allowing to combine a task_block with an execution policy. This implies a minor breaking change as the hpx::parallel::task_block is now a template.
  • Added new LCOs: hpx::lcos::latch and hpx::lcos::local::latch which semantically conform to the proposed std::latch (see N4399).
  • Added performance counters exposing data related to data transferred by input/output (filesystem) operations (thanks to Maciej Brodowicz).
  • Added performance counters allowing to track the number of action invocations (local and remote invocations).
  • Added new command line options --hpx:print-counter-at and --hpx:reset-counters.
  • The hpx::vector component has been renamed to hpx::partitioned_vector to make it explicit that the underlying memory is not contiguous.
  • Introduced a completely new and uniform higher-level parallelism API which is based on executors. All existing parallelism APIs have been adapted to this. We have added a large number of different executor types, such as a numa-aware executor, a this-thread executor, etc.
  • Added support for the MingW toolchain on Windows (thanks to Eric Lemanissier).
  • HPX now includes support for APEX, (Autonomic Performance Environment for eXascale). APEX is an instrumentation and software adaptation library that provides an interface to TAU profiling / tracing as well as runtime adaptation of HPX applications through policy definitions. For more information and documentation, please see https://github.com/khuck/xpress-apex. To enable APEX at configuration time, specify -DHPX_WITH_APEX=On. To also include support for TAU profiling, specify -DHPX_WITH_TAU=On and specify the -DTAU_ROOT, -DTAU_ARCH and -DTAU_OPTIONS cmake parameters.
  • We have implemented many more of the parallel algorithms. Please see IS#1141 for the list of all available parallel algorithms (thanks to Daniel Bourgeois and John Biddiscombe for contributing their work).
Breaking Changes
  • We are moving into the direction of unifying managed and simple components. In order to stop exposing the old facilities, all examples have been converted to use the new classes. The breaking change in this release is that performance counters are now a hpx::components::component_base instead of hpx::components::managed_component_base.
  • We removed the support for stackless threads. It turned out that there was no performance benefit when using stackless threads. As such, we decided to clean up our codebase. This feature was not documented.
  • The CMake project name has changed from 'hpx' to 'HPX' for consistency and compatibilty with naming conventions and other CMake projects. Generated config files go into <prefix>/lib/cmake/HPX and not <prefix>/lib/cmake/hpx.
  • The macro HPX_REGISTER_MINIMAL_COMPONENT_FACTORY has been deprecated. Please use HPX_REGISTER_COMPONENT instead. The old macro will be removed in the next release.
  • The obsolete distributing_factory and binpacking_factory components have been removed. The corresponding functionality is now provided by the hpx::new_<>() API function in conjunction with the hpx::default_layout and hpx::binpacking distribution policies (hpx::default_distribution_policy and hpx::binpacking_distribution_policy)
  • The API function hpx::new_colocated has been deprecated. Please use the consolidated API hpx::new_ in conjunction with the new hpx::colocated distribution policy (hpx::colocating_distribution_policy) instead. The old API function will still be available for at least one release of HPX if the configuration variable HPX_WITH_COLOCATED_BACKWARDS_COMPATIBILITY is enabled.
  • The API function hpx::async_colocated has been deprecated. Please use the consolidated API hpx::async in conjunction with the new hpx::colocated distribution policy (hpx::colocating_distribution_policy) instead. The old API function will still be available for at least one release of HPX if the configuration variable HPX_WITH_COLOCATED_BACKWARDS_COMPATIBILITY is enabled.
  • The obsolete remote_object component has been removed.
  • Replaced the use of Boost.Serialization with our own solution. While the new version is mostly compatible with Boost.Serialization, this change requires some minor code modifications in user code. For more information, please see the corresponding announcement on the hpx-users@stellar.cct.lsu.edu mailing list.
  • The names used by cmake to influence various configuration options have been unified. The new naming scheme relies on all configuration constants to start with HPX_WITH_..., while the preprocessor constant which is used at build time starts with HPX_HAVE_.... For instance, the former cmake command line -DHPX_MALLOC=... now has to be specified a -DHPX_WITH_MALLOC=... and will cause the preprocessor constant HPX_HAVE_MALLOC to be defined. The actual name of the constant (i.e. MALLOC) has not changed. Please see the corresponding documentation for more details (CMake Variables used to configure HPX).
  • The get_gid() functions exposed by the component base classes hpx::components::server::simple_component_base, hpx::components::server::managed_component_base, and hpx::components::server::fixed_component_base have been replaced by two new functions: get_unmanaged_id() and get_id(). To enable the old function name for backwards compatibility, use the cmake configuration option HPX_WITH_COMPONENT_GET_GID_COMPATIBILITY=On.
  • All functions which were named get_gid() but were returning hpx::id_type have been renamed to get_id(). To enable the old function names for backwards compatibility, use the cmake configuration option HPX_WITH_COMPONENT_GET_GID_COMPATIBILITY=On.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • PR#1855 - Completely removing external/endian
  • PR#1854 - Don't pollute CMAKE_CXX_FLAGS through find_package()
  • PR#1853 - Updating CMake configuration to get correct version of TAU library
  • PR#1852 - Fixing Performance Problems with MPI Parcelport
  • PR#1851 - Fixing hpx_add_link_flag() and hpx_remove_link_flag()
  • PR#1850 - Fixing 1836, adding parallel::sort
  • PR#1849 - Fixing configuration for use of more than 64 cores
  • PR#1848 - Change default APEX version for release
  • PR#1847 - Fix client_base::then on release
  • PR#1846 - Removing broken lcos::local::channel from release
  • PR#1845 - Adding example demonstrating a possible safe-object implementation to release
  • PR#1844 - Removing stubs from accumulator examples
  • PR#1843 - Don't pollute CMAKE_CXX_FLAGS through find_package()
  • PR#1841 - Fixing client_base<>::then
  • PR#1840 - Adding example demonstrating a possible safe-object implementation
  • PR#1838 - Update version rc1
  • PR#1837 - Removing broken lcos::local::channel
  • PR#1835 - Adding exlicit move constructor and assignment operator to hpx::lcos::promise
  • PR#1834 - Making hpx::lcos::promise move-only
  • PR#1833 - Adding fedora docs
  • IS#1832 - hpx::lcos::promise<> must be move-only
  • PR#1831 - Fixing resource manager gcc5.2
  • PR#1830 - Fix intel13
  • PR#1829 - Unbreaking thread test
  • PR#1828 - Fixing #1620
  • PR#1827 - Fixing a memory management issue for the Parquet application
  • IS#1826 - Memory management issue in hpx::lcos::promise
  • PR#1825 - Adding hpx::components::component and hpx::components::component_base
  • PR#1823 - Adding git commit id to circleci build
  • PR#1822 - applying fixes suggested by clang 3.7
  • PR#1821 - Hyperlink fixes
  • PR#1820 - added parallel multi-locality sanity test
  • PR#1819 - Fixing #1667
  • IS#1817 - Hyperlinks generated by inspect tool are wrong
  • PR#1816 - Support hpxrx
  • PR#1814 - Fix async to dispatch to the correct locality in all cases
  • IS#1813 - async(launch::..., action(), ...) always invokes locally
  • PR#1812 - fixed syntax error in CMakeLists.txt
  • PR#1811 - Agas optimizations
  • PR#1810 - drop superfluous typedefs
  • PR#1809 - Allow HPX to be used as an optional package in 3rd party code
  • PR#1808 - Fixing #1723
  • PR#1807 - Making sure resolve_localities does not hang during normal operation
  • IS#1806 - Spinlock no longer movable and deletes operator '=', breaks MiniGhost
  • IS#1804 - register_with_basename causes hangs
  • PR#1801 - Enhanced the inspect tool to take user directly to the problem with hyperlinks
  • IS#1800 - Problems compiling application on smic
  • PR#1799 - Fixing cv exceptions
  • PR#1798 - Documentation refactoring & updating
  • PR#1797 - Updating the activeharmony CMake module
  • PR#1795 - Fixing cv
  • PR#1794 - Fix connect with hpx::runtime_mode_connect
  • PR#1793 - fix a wrong use of HPX_MAX_CPU_COUNT instead of HPX_HAVE_MAX_CPU_COUNT
  • PR#1792 - Allow for default constructed parcel instances to be moved
  • PR#1791 - Fix connect with hpx::runtime_mode_connect
  • IS#1790 - assertion 'action_.get()' failed: HPX(assertion_failure) when running Octotiger with pull request 1786
  • PR#1789 - Fixing discover_counter_types API function
  • IS#1788 - connect with hpx::runtime_mode_connect
  • IS#1787 - discover_counter_types not working
  • PR#1786 - Changing addressing_service to use std::unordered_map instead of std::map
  • PR#1785 - Fix is_iterator for container algorithms
  • PR#1784 - Adding new command line options:
  • PR#1783 - Minor changes for APEX support
  • PR#1782 - Drop legacy forwarding action traits
  • PR#1781 - Attempt to resolve the race between cv::wait_xxx and cv::notify_all
  • PR#1780 - Removing serialize_sequence
  • PR#1779 - Fixed #1501: hwloc configuration options are wrong for MIC
  • PR#1778 - Removing ability to enable/disable parcel handling
  • PR#1777 - Completely removing stackless threads
  • PR#1776 - Cleaning up util/plugin
  • PR#1775 - Agas fixes
  • PR#1774 - Action invocation count
  • PR#1773 - replaced MSVC variable with WIN32
  • PR#1772 - Fixing Problems in MPI parcelport and future serialization.
  • PR#1771 - Fixing intel 13 compiler errors related to variadic template template parameters for lcos::when_ tests
  • PR#1770 - Forwarding decay to std::
  • PR#1769 - Add more characters with special regex meaning to the existing patch
  • PR#1768 - Adding test for receive_buffer
  • PR#1767 - Making sure that uptime counter throws exception on any attempt to be reset
  • PR#1766 - Cleaning up code related to throttling scheduler
  • PR#1765 - Restricting thread_data to creating only with intrusive_pointers
  • PR#1764 - Fixing 1763
  • IS#1763 - UB in thread_data::operator delete
  • PR#1762 - Making sure all serialization registries/factories are unique
  • PR#1761 - Fixed #1751: hpx::future::wait_for fails a simple test
  • PR#1758 - Fixing #1757
  • IS#1757 - pinning not correct using --hpx:bind
  • IS#1756 - compilation error with MinGW
  • PR#1755 - Making output serialization const-correct
  • IS#1753 - HPX performance degrades with time since execution begins
  • IS#1752 - Error in AGAS
  • IS#1751 - hpx::future::wait_for fails a simple test
  • PR#1750 - Removing hpx_fwd.hpp includes
  • PR#1749 - Simplify result_of and friends
  • PR#1747 - Removed superfluous code from message_buffer.hpp
  • PR#1746 - Tuple dependencies
  • IS#1745 - Broken when_some which takes iterators
  • PR#1744 - Refining archive interface
  • PR#1743 - Fixing when_all when only a single future is passed
  • PR#1742 - Config includes
  • PR#1741 - Os executors
  • IS#1740 - hpx::promise has some problems
  • PR#1739 - Parallel composition with generic containers
  • IS#1738 - After building program and successfully linking to a version of hpx DHPX_DIR seems to be ignored
  • IS#1737 - Uptime problems
  • PR#1736 - added convenience c-tor and begin()/end() to serialize_buffer
  • PR#1735 - Config includes
  • PR#1734 - Fixed #1688: Add timer counters for tfunc_total and exec_total
  • IS#1733 - Add unit test for hpx/lcos/local/receive_buffer.hpp
  • PR#1732 - Renaming get_os_thread_count
  • PR#1731 - Basename registration
  • IS#1730 - Use after move of thread_init_data
  • PR#1729 - Rewriting channel based on new gate component
  • PR#1728 - Fixing #1722
  • PR#1727 - Fixing compile problems with apply_colocated
  • PR#1726 - Apex integration
  • PR#1725 - fixed test timeouts
  • PR#1724 - Renaming vector
  • IS#1723 - Drop support for intel compilers and gcc 4.4. based standard libs
  • IS#1722 - Add support for detecting non-ready futures before serialization
  • PR#1721 - Unifying parallel executors, initializing from launch policy
  • PR#1720 - dropped superfluous typedef
  • IS#1718 - Windows 10 x64, VS 2015 - Unknown CMake command "add_hpx_pseudo_target".
  • PR#1717 - Timed executor traits for thread-executors
  • PR#1716 - serialization of arrays didn't work with non-pod types. fixed
  • PR#1715 - List serialization
  • PR#1714 - changing misspellings
  • PR#1713 - Fixed distribution policy executors
  • PR#1712 - Moving library detection to be executed after feature tests
  • PR#1711 - Simplify parcel
  • PR#1710 - Compile only tests
  • PR#1709 - Implemented timed executors
  • PR#1708 - Implement parallel::executor_traits for thread-executors
  • PR#1707 - Various fixes to threads::executors to make custom schedulers work
  • PR#1706 - Command line option --hpx:cores does not work as expected
  • IS#1705 - command line option --hpx:cores does not work as expected
  • PR#1704 - vector deserialization is speeded up a little
  • PR#1703 - Fixing shared_mutes
  • IS#1702 - Shared_mutex does not compile with no_mutex cond_var
  • PR#1701 - Add distribution_policy_executor
  • PR#1700 - Executor parameters
  • PR#1699 - Readers writer lock
  • PR#1698 - Remove leftovers
  • PR#1697 - Fixing held locks
  • PR#1696 - Modified Scan Partitioner for Algorithms
  • PR#1695 - This thread executors
  • PR#1694 - Fixed #1688: Add timer counters for tfunc_total and exec_total
  • PR#1693 - Fix #1691: is_executor template specification fails for inherited executors
  • PR#1692 - Fixed #1662: Possible exception source in coalescing_message_handler
  • IS#1691 - is_executor template specification fails for inherited executors
  • PR#1690 - added macro for non-intrusive serialization of classes without a default c-tor
  • PR#1689 - Replace value_or_error with custom storage, unify future_data state
  • IS#1688 - Add timer counters for tfunc_total and exec_total
  • PR#1687 - Fixed interval timer
  • PR#1686 - Fixing cmake warnings about not existing pseudo target dependencies
  • PR#1685 - Converting partitioners to use bulk async execute
  • PR#1683 - Adds a tool for inspect that checks for character limits
  • PR#1682 - Change project name to (uppercase) HPX
  • PR#1681 - Counter shortnames
  • PR#1680 - Extended Non-intrusive Serialization to Ease Usage for Library Developers
  • PR#1679 - Working on 1544: More executor changes
  • PR#1678 - Transpose fixes
  • PR#1677 - Improve Boost compatibility check
  • PR#1676 - 1d stencil fix
  • IS#1675 - hpx project name is not HPX
  • PR#1674 - Fixing the MPI parcelport
  • PR#1673 - added move semantics to map/vector deserialization
  • PR#1672 - Vs2015 await
  • PR#1671 - Adapt transform for #1668
  • PR#1670 - Started to work on #1668
  • PR#1669 - Add this_thread_executors
  • IS#1667 - Apple build instructions in docs are out of date
  • PR#1666 - Apex integration
  • PR#1665 - Fixes an error with the whitespace check that showed the incorrect location of the error
  • IS#1664 - Inspect tool found incorrect endline whitespace
  • PR#1663 - Improve use of locks
  • IS#1662 - Possible exception source in coalescing_message_handler
  • PR#1661 - Added support for 128bit number serialization
  • PR#1660 - Serialization 128bits
  • PR#1659 - Implemented inner_product and adjacent_diff algos
  • PR#1658 - Add serialization for std::set (as there is for std::vector and std::map)
  • PR#1657 - Use of shared_ptr in io_service_pool changed to unique_ptr
  • IS#1656 - 1d_stencil codes all have wrong factor
  • PR#1654 - When using runtime_mode_connect, find the correct localhost public ip address
  • PR#1653 - Fixing 1617
  • PR#1652 - Remove traits::action_may_require_id_splitting
  • PR#1651 - Fixed performance counters related to AGAS cache timings
  • PR#1650 - Remove leftovers of traits::type_size
  • PR#1649 - Shorten target names on Windows to shorten used path names
  • PR#1648 - Fixing problems introduced by merging #1623 for older compilers
  • PR#1647 - Simplify running automatic builds on Windows
  • IS#1646 - Cache insert and update performance counters are broken
  • IS#1644 - Remove leftovers of traits::type_size
  • IS#1643 - Remove traits::action_may_require_id_splitting
  • PR#1642 - Adds spell checker to the inspect tool for qbk and doxygen comments
  • PR#1640 - First step towards fixing 688
  • PR#1639 - Re-apply remaining changes from limit_dataflow_recursion branch
  • PR#1638 - This fixes possible deadlock in the test ignore_while_locked_1485
  • PR#1637 - Fixing hpx::wait_all() invoked with two vector<future<T>>
  • PR#1636 - Partially re-apply changes from limit_dataflow_recursion branch
  • PR#1635 - Adding missing test for #1572
  • PR#1634 - Revert "Limit recursion-depth in dataflow to a configurable constant"
  • PR#1633 - Add command line option to ignore batch environment
  • PR#1631 - hpx::lcos::queue exhibits strange behavior
  • PR#1630 - Fixed endline_whitespace_check.cpp to detect lines with only whitespace
  • IS#1629 - Inspect trailing whitespace checker problem
  • PR#1628 - Removed meaningless const qualifiers. Minor icpc fix.
  • PR#1627 - Fixing the queue LCO and add example demonstrating its use
  • PR#1626 - Deprecating get_gid(), add get_id() and get_unmanaged_id()
  • PR#1625 - Allowing to specify whether to send credits along with message
  • IS#1624 - Lifetime issue
  • IS#1623 - hpx::wait_all() invoked with two vector<future<T>> fails
  • PR#1622 - Executor partitioners
  • PR#1621 - Clean up coroutines implementation
  • IS#1620 - Revert #1535
  • PR#1619 - Fix result type calculation for hpx::make_continuation
  • PR#1618 - Fixing RDTSC on Xeon/Phi
  • IS#1617 - hpx cmake not working when run as a subproject
  • IS#1616 - cmake problem resulting in RDTSC not working correctly for Xeon Phi creates very strange results for duration counters
  • IS#1615 - hpx::make_continuation requires input and output to be the same
  • PR#1614 - Fixed remove copy test
  • IS#1613 - Dataflow causes stack overflow
  • PR#1612 - Modified foreach partitioner to use bulk execute
  • PR#1611 - Limit recursion-depth in dataflow to a configurable constant
  • PR#1610 - Increase timeout for CircleCI
  • PR#1609 - Refactoring thread manager, mainly extracting thread pool
  • PR#1608 - Fixed running multiple localities without localities parameter
  • PR#1607 - More algorithm fixes to adjacentfind
  • IS#1606 - Running without localities parameter binds to bogus port range
  • IS#1605 - Too many serializations
  • PR#1604 - Changes the HPX image into a hyperlink
  • PR#1601 - Fixing problems with remove_copy algorithm tests
  • PR#1600 - Actions with ids cleanup
  • PR#1599 - Duplicate binding of global ids should fail
  • PR#1598 - Fixing array access
  • PR#1597 - Improved the reliability of connecting/disconnecting localities
  • IS#1596 - Duplicate id binding should fail
  • PR#1595 - Fixing more cmake config constants
  • PR#1594 - Fixing preprocessor constant used to enable C++11 chrono
  • PR#1593 - Adding operator|() for hpx::launch
  • IS#1592 - Error (typo) in the docs
  • IS#1590 - CMake fails when CMAKE_BINARY_DIR contains '+'.
  • IS#1589 - Disconnecting a locality results in segfault using heartbeat example
  • PR#1588 - Fix doc string for config option HPX_WITH_EXAMPLES
  • PR#1586 - Fixing 1493
  • PR#1585 - Additional Check for Inspect Tool to detect Endline Whitespace
  • IS#1584 - Clean up coroutines implementation
  • PR#1583 - Adding a check for end line whitespace
  • PR#1582 - Attempt to fix assert firing after scheduling loop was exited
  • PR#1581 - Fixed adjacentfind_binary test
  • PR#1580 - Prevent some of the internal cmake lists from growing indefinitely
  • PR#1579 - Removing type_size trait, replacing it with special archive type
  • IS#1578 - Remove demangle_helper
  • PR#1577 - Get ptr problems
  • IS#1576 - Refactor async, dataflow, and future::then
  • PR#1575 - Fixing tests for parallel rotate
  • PR#1574 - Cleaning up schedulers
  • PR#1573 - Fixing thread pool executor
  • PR#1572 - Fixing number of configured localities
  • PR#1571 - Reimplement decay
  • PR#1570 - Refactoring async, apply, and dataflow APIs
  • PR#1569 - Changed range for mach-o library lookup
  • PR#1568 - Mark decltype support as required
  • PR#1567 - Removed const from algorithms
  • IS#1566 - CMAKE Configuration Test Failures for clang 3.5 on debian
  • PR#1565 - Dylib support
  • PR#1564 - Converted partitioners and some algorithms to use executors
  • PR#1563 - Fix several #includes for Boost.Preprocessor
  • PR#1562 - Adding configuration option disabling/enabling all message handlers
  • PR#1561 - Removed all occurrences of boost::move replacing it with std::move
  • PR#1558 - Revisit async/apply SFINAE conditions
  • PR#1557 - Removing type_size trait, replacing it with special archive type
  • PR#1556 - Executor algorithms
  • PR#1555 - Remove the necessity to specify archive flags on the receiving end
  • PR#1554 - Removing obsolete Boost.Serialization macros
  • PR#1553 - Properly fix HPX_DEFINE_*_ACTION macros
  • PR#1552 - Fixed algorithms relying on copy_if implementation
  • PR#1551 - Pxfs - Modifying FindOrangeFS.cmake based on OrangeFS 2.9.X
  • IS#1550 - Passing plain identifier inside HPX_DEFINE_PLAIN_ACTION_1
  • PR#1549 - Fixing intel14/libstdc++4.4
  • PR#1548 - Moving raw_ptr to detail namespace
  • PR#1547 - Adding support for executors to future.then
  • PR#1546 - Executor traits result types
  • PR#1545 - Integrate executors with dataflow
  • PR#1543 - Fix potential zero-copy for primarynamespace::bulk_service_async et.al.
  • PR#1542 - Merging HPX0.9.10 into pxfs branch
  • PR#1541 - Removed stale cmake tests, unused since the great cmake refactoring
  • PR#1540 - Fix idle-rate on platforms without TSC
  • PR#1539 - Reporting situation if zero-copy-serialization was performed by a parcel generated from a plain apply/async
  • PR#1538 - Changed return type of bulk executors and added test
  • IS#1537 - Incorrect cpuid config tests
  • PR#1536 - Changed return type of bulk executors and added test
  • PR#1535 - Make sure promise::get_gid() can be called more than once
  • PR#1534 - Fixed async_callback with bound callback
  • PR#1533 - Updated the link in the documentation to a publically- accessible URL
  • PR#1532 - Make sure sync primitives are not copyable nor movable
  • PR#1531 - Fix unwrapped issue with future ranges of void type
  • PR#1530 - Serialization complex
  • IS#1528 - Unwrapped issue with future<void>
  • IS#1527 - HPX does not build with Boost 1.58.0
  • PR#1526 - Added support for boost.multi_array serialization
  • PR#1525 - Properly handle deferred futures, fixes #1506
  • PR#1524 - Making sure invalid action argument types generate clear error message
  • IS#1522 - Need serialization support for boost multi array
  • IS#1521 - Remote async and zero-copy serialization optimizations don't play well together
  • PR#1520 - Fixing UB whil registering polymorphic classes for serialization
  • PR#1519 - Making detail::condition_variable safe to use
  • PR#1518 - Fix when_some bug missing indices in its result
  • IS#1517 - Typo may affect CMake build system tests
  • PR#1516 - Fixing Posix context
  • PR#1515 - Fixing Posix context
  • PR#1514 - Correct problems with loading dynamic components
  • PR#1513 - Fixing intel glibc4 4
  • IS#1508 - memory and papi counters do not work
  • IS#1507 - Unrecognized Command Line Option Error causing exit status 0
  • IS#1506 - Properly handle deferred futures
  • PR#1505 - Adding #include - would not compile without this
  • IS#1502 - boost::filesystem::exists throws unexpected exception
  • IS#1501 - hwloc configuration options are wrong for MIC
  • PR#1504 - Making sure boost::filesystem::exists() does not throw
  • PR#1500 - Exit application on --hpx:version/-v and --hpx:info
  • PR#1498 - Extended task block
  • PR#1497 - Unique ptr serialization
  • PR#1496 - Unique ptr serialization (closed)
  • PR#1495 - Switching circleci build type to debug
  • IS#1494 - --hpx:version/-v does not exit after printing version information
  • IS#1493 - add an "hpx_" prefix to libraries and components to avoid name conflicts
  • IS#1492 - Define and ensure limitations for arguments to async/apply
  • PR#1489 - Enable idle rate counter on demand
  • PR#1488 - Made sure detail::condition_variable can be safely destroyed
  • PR#1487 - Introduced default (main) template implementation for ignore_while_checking
  • PR#1486 - Add HPX inspect tool
  • IS#1485 - ignore_while_locked doesn't support all Lockable types
  • PR#1484 - Docker image generation
  • PR#1483 - Move external endian library into HPX
  • PR#1482 - Actions with integer type ids
  • IS#1481 - Sync primitives safe destruction
  • IS#1480 - Move external/boost/endian into hpx/util
  • IS#1478 - Boost inspect violations
  • PR#1479 - Adds serialization for arrays; some futher/minor fixes
  • PR#1477 - Fixing problems with the Intel compiler using a GCC 4.4 std library
  • PR#1476 - Adding hpx::lcos::latch and hpx::lcos::local::latch
  • IS#1475 - Boost inspect violations
  • PR#1473 - Fixing action move tests
  • IS#1471 - Sync primitives should not be movable
  • PR#1470 - Removing hpx::util::polymorphic_factory
  • PR#1468 - Fixed container creation
  • IS#1467 - HPX application fail during finalization
  • IS#1466 - HPX doesn't pick up Torque's nodefile on SuperMIC
  • IS#1464 - HPX option for pre and post bootstrap performance counters
  • PR#1463 - Replacing async_colocated(id, ...) with async(colocated(id), ...)
  • PR#1462 - Consolidated task_region with N4411
  • PR#1461 - Consolidate inconsistent CMake option names
  • IS#1460 - Which malloc is actually used? or at least which one is HPX built with
  • IS#1459 - Make cmake configure step fail explicitly if compiler version is not supported
  • IS#1458 - Update parallel::task_region with N4411
  • PR#1456 - Consolidating new_<>()
  • IS#1455 - Replace async_colocated(id, ...) with async(colocated(id), ...)
  • PR#1454 - Removed harmful std::moves from return statements
  • PR#1453 - Use range-based for-loop instead of Boost.Foreach
  • PR#1452 - C++ feature tests
  • PR#1451 - When serializing, pass archive flags to traits::get_type_size
  • IS#1450 - traits:get_type_size needs archive flags to enable zero_copy optimizations
  • IS#1449 - "couldn't create performance counter" - AGAS
  • IS#1448 - Replace distributing factories with new_<T[]>(...)
  • PR#1447 - Removing obsolete remote_object component
  • PR#1446 - Hpx serialization
  • PR#1445 - Replacing travis with circleci
  • PR#1443 - Always stripping HPX command line arguments before executing start function
  • PR#1442 - Adding --hpx:bind=none to disable thread affinities
  • IS#1439 - Libraries get linked in multiple times, RPATH is not properly set
  • PR#1438 - Removed superfluous typedefs
  • IS#1437 - hpx::init() should strip HPX-related flags from argv
  • IS#1436 - Add strong scaling option to htts
  • PR#1435 - Adding async_cb, async_continue_cb, and async_colocated_cb
  • PR#1434 - Added missing install rule, removed some dead CMake code
  • PR#1433 - Add GitExternal and SubProject cmake scripts from eyescale/cmake repo
  • IS#1432 - Add command line flag to disable thread pinning
  • PR#1431 - Fix #1423
  • IS#1430 - Inconsistent CMake option names
  • IS#1429 - Configure setting HPX_HAVE_PARCELPORT_MPI is ignored
  • PR#1428 - Fixes #1419 (closed)
  • PR#1427 - Adding stencil_iterator and transform_iterator
  • PR#1426 - Fixes #1419
  • PR#1425 - During serialization memory allocation should honour allocator chunk size
  • IS#1424 - chunk allocation during serialization does not use memory pool/allocator chunk size
  • IS#1423 - Remove HPX_STD_UNIQUE_PTR
  • IS#1422 - hpx:threads=all allocates too many os threads
  • PR#1420 - added .travis.yml
  • IS#1419 - Unify enums: hpx::runtime::state and hpx::state
  • PR#1416 - Adding travis builder
  • IS#1414 - Correct directory for dispatch_gcc46.hpp iteration
  • IS#1410 - Set operation algorithms
  • IS#1389 - Parallel algorithms relying on scan partitioner break for small number of elements
  • IS#1325 - Exceptions thrown during parcel handling are not handled correctly
  • IS#1315 - Errors while running performance tests
  • IS#1309 - hpx::vector partitions are not easily extendable by applications
  • PR#1300 - Added serialization/de-serialization to examples.tuplespace
  • IS#1251 - hpx::threads::get_thread_count doesn't consider pending threads
  • IS#1008 - Decrease in application performance overtime; occasional spikes of major slowdown
  • IS#1001 - Zero copy serialization raises assert
  • IS#721 - Make HPX usable for Xeon Phi
  • IS#524 - Extend scheduler to support threads which can't be stolen
General Changes

This is the 12th official release of HPX. It coincides with the 7th anniversary of the first commit to our source code repository. Since then, we have seen over 12300 commits amounting to more than 220000 lines of C++ code.

The major focus of this release was to improve the reliability of large scale runs. We believe to have achieved this goal as we now can reliably run HPX applications on up to ~24k cores. We have also shown that HPX can be used with success for symmetric runs (applications using both, host cores and Intel Xeon/Phi coprocessors). This is a huge step forward in terms of the usability of HPX. The main focus of this work involved isolating the causes of the segmentation faults at start up and shut down. Many of these issues were discovered to be the result of the suspension of threads which hold locks.

A very important improvement introduced with this release is the refactoring of the code representing our parcel-port implementation. Parcel- ports can now be implemented by 3rd parties as independent plugins which are dynamically loaded at runtime (static linking of parcel-ports is also supported). This refactoring also includes a massive improvement of the performance of our existing parcel-ports. We were able to significantly reduce the networking latencies and to improve the available networking bandwidth. Please note that in this release we disabled the ibverbs and ipc parcel ports as those have not been ported to the new plugin system yet (see IS#839).

Another corner stone of this release is our work towards a complete implementation of N4409 (Working Draft, Technical Specification for C++ Extensions for Parallelism). This document defines a set of parallel algorithms to be added to the C++ standard library. We now have implemented about 75% of all specified parallel algorithms (see Parallel Algorithms for more details). We also implemented some extensions to N4409 allowing to invoke all of the algorithms asynchronously.

This release adds a first implementation of hpx::vector which is a distributed data structure closely aligned to the functionality of std::vector. The difference is that hpx::vector stores the data in partitions where the partitions can be distributed over different localities. We started to work on allowing to use the parallel algorithms with hpx::vector. At this point we have implemented only a few of the parallel algorithms to support distributed data structures (like hpx::vector) for testing purposes (see IS#1338 for a documentation of our progress).

Breaking Changes

With this release we put a lot of effort into changing the code base to be more compatible to C++11. These changes have caused the following issues for backward compatibility:

  • Move to Variadics- All of the API now uses variadic templates. However, this change required to modify the argument sequence for some of the exiting API functions (hpx::async_continue, hpx::apply_continue, hpx::when_each, hpx::wait_each, synchronous invocation of actions).
  • Changes to Macros- We also removed the macros HPX_STD_FUNCTION and HPX_STD_TUPLE. This shouldn't affect any user code as we replaced HPX_STD_FUNCTION with hpx::util::function_nonser which was the default expansion used for this macro. All HPX API functions which expect a hpx::util::function_nonser (or a hpx::util::unique_function_nonser) can now be transparently called with a compatible std::function instead. Similarly, HPX_STD_TUPLE was replaced by its default expansion as well: hpx::util::tuple.
  • Changes to hpx::unique_future- hpx::unique_future, which was deprecated in the previous release for hpx::future is now completely removed from HPX. This completes the transition to a completely standards conforming implementation of hpx::future.
  • Changes to Supported Compilers- Finally, in order to utilize more C++11 semantics, we have officially dropped support for GCC 4.4 and MSVC 2012. Please see our Build Prerequisites page for more details.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • IS#1402 - Internal shared_future serialization copies
  • IS#1399 - Build takes unusually long time...
  • IS#1398 - Tests using the scan partitioner are broken on at least gcc 4.7 and intel compiler
  • IS#1397 - Completely remove hpx::unique_future
  • IS#1396 - Parallel scan algorithms with different initial values
  • IS#1395 - Race Condition - 1d_stencil_8 - SuperMIC
  • IS#1394 - "suspending thread while at least one lock is being held" - 1d_stencil_8 - SuperMIC
  • IS#1393 - SEGFAULT in 1d_stencil_8 on SuperMIC
  • IS#1392 - Fixing #1168
  • IS#1391 - Parallel Algorithms for scan partitioner for small number of elements
  • IS#1387 - Failure with more than 4 localities
  • IS#1386 - Dispatching unhandled exceptions to outer user code
  • IS#1385 - Adding Copy algorithms, fixing parallel::copy_if
  • IS#1384 - Fixing 1325
  • IS#1383 - Fixed #504: Refactor Dataflow LCO to work with futures, this removes the dataflow component as it is obsolete
  • IS#1382 - is_sorted, is_sorted_until and is_partitioned algorithms
  • IS#1381 - fix for CMake versions prior to 3.1
  • IS#1380 - resolved warning in CMake 3.1 and newer
  • IS#1379 - Compilation error with papi
  • IS#1378 - Towards safer migration
  • IS#1377 - HPXConfig.cmake should include TCMALLOC_LIBRARY and TCMALLOC_INCLUDE_DIR
  • IS#1376 - Warning on uninitialized member
  • IS#1375 - Fixing 1163
  • IS#1374 - Fixing the MSVC 12 release builder
  • IS#1373 - Modifying parallel search algorithm for zero length searches
  • IS#1372 - Modifying parallel search algorithm for zero length searches
  • IS#1371 - Avoid holding a lock during agas::incref while doing a credit split
  • IS#1370 - --hpx:bind throws unexpected error
  • IS#1369 - Getting rid of (void) in loops
  • IS#1368 - Variadic templates support for tuple
  • IS#1367 - One last batch of variadic templates support
  • IS#1366 - Fixing symbolic namespace hang
  • IS#1365 - More held locks
  • IS#1364 - Add counters 1363
  • IS#1363 - Add thread overhead counters
  • IS#1362 - Std config removal
  • IS#1361 - Parcelport plugins
  • IS#1360 - Detuplify transfer_action
  • IS#1359 - Removed obsolete checks
  • IS#1358 - Fixing 1352
  • IS#1357 - Variadic templates support for runtime_support and components
  • IS#1356 - fixed coordinate test for intel13
  • IS#1355 - fixed coordinate.hpp
  • IS#1354 - Lexicographical Compare completed
  • IS#1353 - HPX should set Boost_ADDITIONAL_VERSIONS flags
  • IS#1352 - Error: Cannot find action '' in type registry: HPX(bad_action_code)
  • IS#1351 - Variadic templates support for appliers
  • IS#1350 - Actions simplification
  • IS#1349 - Variadic when and wait functions
  • IS#1348 - Added hpx_init header to test files
  • IS#1347 - Another batch of variadic templates support
  • IS#1346 - Segmented copy
  • IS#1345 - Attempting to fix hangs during shutdown
  • IS#1344 - Std config removal
  • IS#1343 - Removing various distribution policies for hpx::vector
  • IS#1342 - Inclusive scan
  • IS#1341 - Exclusive scan
  • IS#1340 - Adding parallel::count for distributed data structures, adding tests
  • IS#1339 - Update argument order for transform_reduce
  • IS#1337 - Fix dataflow to handle properly ranges of futures
  • IS#1336 - dataflow needs to hold onto futures passed to it
  • IS#1335 - Fails to compile with msvc14
  • IS#1334 - Examples build problem
  • IS#1333 - Distributed transform reduce
  • IS#1332 - Variadic templates support for actions
  • IS#1331 - Some ambiguous calls of map::erase have been prevented by adding additional check in locality constructor.
  • IS#1330 - Defining Plain Actions does not work as described in the documentation
  • IS#1329 - Distributed vector cleanup
  • IS#1328 - Sync docs and comments with code in hello_world example
  • IS#1327 - Typos in docs
  • IS#1326 - Documentation and code diverged in Fibonacci tutorial
  • IS#1325 - Exceptions thrown during parcel handling are not handled correctly
  • IS#1324 - fixed bandwidth calculation
  • IS#1323 - mmap() failed to allocate thread stack due to insufficient resources
  • IS#1322 - HPX fails to build aa182cf
  • IS#1321 - Limiting size of outgoing messages while coalescing parcels
  • IS#1320 - passing a future with launch::deferred in remote function call causes hang
  • IS#1319 - An exception when tries to specify number high priority threads with abp-priority
  • IS#1318 - Unable to run program with abp-priority and numa-sensitivity enabled
  • IS#1317 - N4071 Search/Search_n finished, minor changes
  • IS#1316 - Add config option to make -Ihpx.run_hpx_main!=1 the default
  • IS#1314 - Variadic support for async and apply
  • IS#1313 - Adjust when_any/some to the latest proposed interfaces
  • IS#1312 - Fixing #857: hpx::naming::locality leaks parcelport specific information into the public interface
  • IS#1311 - Distributed get'er/set'er_values for distributed vector
  • IS#1310 - Crashing in hpx::parcelset::policies::mpi::connection_handler::handle_messages() on SuperMIC
  • IS#1308 - Unable to execute an application with --hpx:threads
  • IS#1307 - merge_graph linking issue
  • IS#1306 - First batch of variadic templates support
  • IS#1305 - Create a compiler wrapper
  • IS#1304 - Provide a compiler wrapper for hpx
  • IS#1303 - Drop support for GCC44
  • IS#1302 - Fixing #1297
  • IS#1301 - Compilation error when tried to use boost range iterators with wait_all
  • IS#1298 - Distributed vector
  • IS#1297 - Unable to invoke component actions recursively
  • IS#1294 - HDF5 build error
  • IS#1275 - The parcelport implementation is non-optimal
  • IS#1267 - Added classes and unit tests for local_file, orangefs_file and pxfs_file
  • IS#1264 - Error "assertion '!m_fun' failed" randomly occurs when using TCP
  • IS#1254 - thread binding seems to not work properly
  • IS#1220 - parallel::copy_if is broken
  • IS#1217 - Find a better way of fixing the issue patched by #1216
  • IS#1168 - Starting HPX on Cray machines using aprun isn't working correctly
  • IS#1085 - Replace startup and shutdown barriers with broadcasts
  • IS#981 - With SLURM, --hpx:threads=8 should not be necessary
  • IS#857 - hpx::naming::locality leaks parcelport specific information into the public interface
  • IS#850 - "flush" not documented
  • IS#763 - Create buildbot instance that uses std::bind as HPX_STD_BIND
  • IS#680 - Convert parcel ports into a plugin system
  • IS#582 - Make exception thrown from HPX threads available from hpx::init
  • IS#504 - Refactor Dataflow LCO to work with futures
  • IS#196 - Don't store copies of the locality network metadata in the gva table
General Changes

We have had over 1500 commits since the last release and we have closed over 200 tickets (bugs, feature requests, pull requests, etc.). These are by far the largest numbers of commits and resolved issues for any of the HPX releases so far. We are especially happy about the large number of people who contributed for the first time to HPX.

  • We completed the transition from the older (non-conforming) implementation of hpx::future to the new and fully conforming version by removing the old code and by renaming the type hpx::unique_future to hpx::future. In order to maintain backwards compatibility with existing code which uses the type hpx::unique_future we support the configuration variable HPX_UNIQUE_FUTURE_ALIAS. If this variable is set to ON while running cmake it will additionally define a template alias for this type.
  • We rewrote and significantly changed our build system. Please have a look at the new (now generated) documentation here: HPX build system. Please revisit your build scripts to adapt to the changes. The most notable changes are:
    • HPX_NO_INSTALL is no longer necessary.
    • For external builds, you need to set HPX_DIR instead of HPX_ROOT as described here: Using CMake.
    • IDEs that support multiple configurations (Visual Studio and XCode) can now be used as intended. that means no build dir.
    • Building HPX statically (without dynamic libraries) is now supported (-DHPX_STATIC_LINKING=On).
    • Please note that many variables used to configure the build process have been renamed to unify the naming conventions (see the section CMake Variables used to configure HPX for more information).
    • This also fixes a long list of issues, for more information see IS#1204.
  • We started to implement various proposals to the C++ Standardization committee related to parallelism and concurrency, most notably N4409 (Working Draft, Technical Specification for C++ Extensions for Parallelism), N4411 (Task Region Rev. 3), and N4313 (Working Draft, Technical Specification for C++ Extensions for Concurrency).
  • We completely remodeled our automatic build system to run builds and unit tests on various systems and compilers. This allows us to find most bugs right as they were introduced and helps to maintain a high level of quality and compatibility. The newest build logs can be found at HPX Buildbot Website.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • IS#1296 - Rename make_error_future to make_exceptional_future, adjust to N4123
  • IS#1295 - building issue
  • IS#1293 - Transpose example
  • IS#1292 - Wrong abs() function used in example
  • IS#1291 - non-synchronized shift operators have been removed
  • IS#1290 - RDTSCP is defined as true for Xeon Phi build
  • IS#1289 - Fixing 1288
  • IS#1288 - Add new performance counters
  • IS#1287 - Hierarchy scheduler broken performance counters
  • IS#1286 - Algorithm cleanup
  • IS#1285 - Broken Links in Documentation
  • IS#1284 - Uninitialized copy
  • IS#1283 - missing boost::scoped_ptr includes
  • IS#1282 - Update documentation of build options for schedulers
  • IS#1281 - reset idle rate counter
  • IS#1280 - Bug when executing on Intel MIC
  • IS#1279 - Add improved when_all/wait_all
  • IS#1278 - Implement improved when_all/wait_all
  • IS#1277 - feature request: get access to argc argv and variables_map
  • IS#1276 - Remove merging map
  • IS#1274 - Weird (wrong) string code in papi.cpp
  • IS#1273 - Sequential task execution policy
  • IS#1272 - Avoid CMake name clash for Boost.Thread library
  • IS#1271 - Updates on HPX Test Units
  • IS#1270 - hpx/util/safe_lexical_cast.hpp is added
  • IS#1269 - Added default value for "LIB" cmake variable
  • IS#1268 - Memory Counters not working
  • IS#1266 - FindHPX.cmake is not installed
  • IS#1263 - apply_remote test takes too long
  • IS#1262 - Chrono cleanup
  • IS#1261 - Need make install for papi counters and this builds all the examples
  • IS#1260 - Documentation of Stencil example claims
  • IS#1259 - Avoid double-linking Boost on Windows
  • IS#1257 - Adding additional parameter to create_thread
  • IS#1256 - added buildbot changes to release notes
  • IS#1255 - Cannot build MiniGhost
  • IS#1253 - hpx::thread defects
  • IS#1252 - HPX_PREFIX is too fragile
  • IS#1250 - switch_to_fiber_emulation does not work properly
  • IS#1249 - Documentation is generated under Release folder
  • IS#1248 - Fix usage of hpx_generic_coroutine_context and get tests passing on powerpc
  • IS#1247 - Dynamic linking error
  • IS#1246 - Make cpuid.cpp C++11 compliant
  • IS#1245 - HPX fails on startup (setting thread affinity mask)
  • IS#1244 - HPX_WITH_RDTSC configure test fails, but should succeed
  • IS#1243 - CTest dashboard info for CSCS CDash drop location
  • IS#1242 - Mac fixes
  • IS#1241 - Failure in Distributed with Boost 1.56
  • IS#1240 - fix a race condition in examples.diskperf
  • IS#1239 - fix wait_each in examples.diskperf
  • IS#1238 - Fixed #1237: hpx::util::portable_binary_iarchive failed
  • IS#1237 - hpx::util::portable_binary_iarchive faileds
  • IS#1235 - Fixing clang warnings and errors
  • IS#1234 - TCP runs fail: Transport endpoint is not connected
  • IS#1233 - Making sure the correct number of threads is registered with AGAS
  • IS#1232 - Fixing race in wait_xxx
  • IS#1231 - Parallel minmax
  • IS#1230 - Distributed run of 1d_stencil_8 uses less threads than spec. & sometimes gives errors
  • IS#1229 - Unstable number of threads
  • IS#1228 - HPX link error (cmake / MPI)
  • IS#1226 - Warning about struct/class thread_counters
  • IS#1225 - Adding parallel::replace etc
  • IS#1224 - Extending dataflow to pass through non-future arguments
  • IS#1223 - Remaining find algorithms implemented, N4071
  • IS#1222 - Merging all the changes
  • IS#1221 - No error output when using mpirun with hpx
  • IS#1219 - Adding new AGAS cache performance counters
  • IS#1216 - Fixing using futures (clients) as arguments to actions
  • IS#1215 - Error compiling simple component
  • IS#1214 - Stencil docs
  • IS#1213 - Using more than a few dozen MPI processes on SuperMike results in a seg fault before getting to hpx_main
  • IS#1212 - Parallel rotate
  • IS#1211 - Direct actions cause the future's shared_state to be leaked
  • IS#1210 - Refactored local::promise to be standard conformant
  • IS#1209 - Improve command line handling
  • IS#1208 - Adding parallel::reverse and parallel::reverse_copy
  • IS#1207 - Add copy_backward and move_backward
  • IS#1206 - N4071 additional algorithms implemented
  • IS#1204 - Cmake simplification and various other minor changes
  • IS#1203 - Implementing new launch policy for (local) async: hpx::launch::fork.
  • IS#1202 - Failed assertion in connection_cache.hpp
  • IS#1201 - pkg-config doesn't add mpi link directories
  • IS#1200 - Error when querying time performance counters
  • IS#1199 - library path is now configurable (again)
  • IS#1198 - Error when querying performance counters
  • IS#1197 - tests fail with intel compiler
  • IS#1196 - Silence several warnings
  • IS#1195 - Rephrase initializers to work with VC++ 2012
  • IS#1194 - Simplify parallel algorithms
  • IS#1193 - Adding parallel::equal
  • IS#1192 - HPX(out_of_memory) on including <hpx/hpx.hpp>
  • IS#1191 - Fixing #1189
  • IS#1190 - Chrono cleanup
  • IS#1189 - Deadlock .. somewhere? (probably serialization)
  • IS#1188 - Removed future::get_status()
  • IS#1186 - Fixed FindOpenCL to find current AMD APP SDK
  • IS#1184 - Tweaking future unwrapping
  • IS#1183 - Extended parallel::reduce
  • IS#1182 - future::unwrap hangs for launch::deferred
  • IS#1181 - Adding all_of, any_of, and none_of and corresponding documentation
  • IS#1180 - hpx::cout defect
  • IS#1179 - hpx::async does not work for member function pointers when called on types with self-defined unary operator*
  • IS#1178 - Implemented variadic hpx::util::zip_iterator
  • IS#1177 - MPI parcelport defect
  • IS#1176 - HPX_DEFINE_COMPONENT_CONST_ACTION_TPL does not have a 2-argument version
  • IS#1175 - Create util::zip_iterator working with util::tuple<>
  • IS#1174 - Error Building HPX on linux, root_certificate_authority.cpp
  • IS#1173 - hpx::cout output lost
  • IS#1172 - HPX build error with Clang 3.4.2
  • IS#1171 - CMAKE_INSTALL_PREFIX ignored
  • IS#1170 - Close hpx_benchmarks repository on Github
  • IS#1169 - Buildbot emails have syntax error in url
  • IS#1167 - Merge partial implementation of standards proposal N3960
  • IS#1166 - Fixed several compiler warnings
  • IS#1165 - cmake warns: "tests.regressions.actions" does not exist
  • IS#1164 - Want my own serialization of hpx::future
  • IS#1162 - Segfault in hello_world example
  • IS#1161 - Use HPX_ASSERT to aid the compiler
  • IS#1160 - Do not put -DNDEBUG into hpx_application.pc
  • IS#1159 - Support Clang 3.4.2
  • IS#1158 - Fixed #1157: Rename when_n/wait_n, add when_xxx_n/wait_xxx_n
  • IS#1157 - Rename when_n/wait_n, add when_xxx_n/wait_xxx_n
  • IS#1156 - Force inlining fails
  • IS#1155 - changed header of printout to be compatible with python csv module
  • IS#1154 - Fixing iostreams
  • IS#1153 - Standard manipulators (like std::endl) do not work with hpx::ostream
  • IS#1152 - Functions revamp
  • IS#1151 - Supressing cmake 3.0 policy warning for CMP0026
  • IS#1150 - Client Serialization error
  • IS#1149 - Segfault on Stampede
  • IS#1148 - Refactoring mini-ghost
  • IS#1147 - N3960 copy_if and copy_n implemented and tested
  • IS#1146 - Stencil print
  • IS#1145 - N3960 hpx::parallel::copy implemented and tested
  • IS#1144 - OpenMP examples 1d_stencil do not build
  • IS#1143 - 1d_stencil OpenMP examples do not build
  • IS#1142 - Cannot build HPX with gcc 4.6 on OS X
  • IS#1140 - Fix OpenMP lookup, enable usage of config tests in external CMake projects.
  • IS#1139 - hpx/hpx/config/compiler_specific.hpp
  • IS#1138 - clean up pkg-config files
  • IS#1137 - Improvements to create binary packages
  • IS#1136 - HPX_GCC_VERSION not defined on all compilers
  • IS#1135 - Avoiding collision between winsock2.h and windows.h
  • IS#1134 - Making sure, that hpx::finalize can be called from any locality
  • IS#1133 - 1d stencil examples
  • IS#1131 - Refactor unique_function implementation
  • IS#1130 - Unique function
  • IS#1129 - Some fixes to the Build system on OS X
  • IS#1128 - Action future args
  • IS#1127 - Executor causes segmentation fault
  • IS#1124 - Adding new API functions: register_id_with_basename, unregister_id_with_basename, find_ids_from_basename; adding test
  • IS#1123 - Reduce nesting of try-catch construct in encode_parcels?
  • IS#1122 - Client base fixes
  • IS#1121 - Update hpxrun.py.in
  • IS#1120 - HTTS2 tests compile errors on v110 (VS2012)
  • IS#1119 - Remove references to boost::atomic in accumulator example
  • IS#1118 - Only build test thread_pool_executor_1114_test if HPX_LOCAL_SCHEDULER is set
  • IS#1117 - local_queue_executor linker error on vc110
  • IS#1116 - Disabled performance counter should give runtime errors, not invalid data
  • IS#1115 - Compile error with Intel C++ 13.1
  • IS#1114 - Default constructed executor is not usable
  • IS#1113 - Fast compilation of logging causes ABI incompatibilities between different NDEBUG values
  • IS#1112 - Using thread_pool_executors causes segfault
  • IS#1111 - hpx::threads::get_thread_data always returns zero
  • IS#1110 - Remove unnecessary null pointer checks
  • IS#1109 - More tests adjustments
  • IS#1108 - Clarify build rules for "libboost_atomic-mt.so"?
  • IS#1107 - Remove unnecessary null pointer checks
  • IS#1106 - network_storage benchmark imporvements, adding legends to plots and tidying layout
  • IS#1105 - Add more plot outputs and improve instructions doc
  • IS#1104 - Complete quoting for parameters of some CMake commands
  • IS#1103 - Work on test/scripts
  • IS#1102 - Changed minimum requirement of window install to 2012
  • IS#1101 - Changed minimum requirement of window install to 2012
  • IS#1100 - Changed readme to no longer specify using MSVC 2010 compiler
  • IS#1099 - Error returning futures from component actions
  • IS#1098 - Improve storage test
  • IS#1097 - data_actions quickstart example calls missing function decorate_action of data_get_action
  • IS#1096 - MPI parcelport broken with new zero copy optimization
  • IS#1095 - Warning C4005: _WIN32_WINNT: Macro redefinition
  • IS#1094 - Syntax error for -DHPX_UNIQUE_FUTURE_ALIAS in master
  • IS#1093 - Syntax error for -DHPX_UNIQUE_FUTURE_ALIAS
  • IS#1092 - Rename unique_future<> back to future<>
  • IS#1091 - Inconsistent error message
  • IS#1090 - On windows 8.1 the examples crashed if using more than one os thread
  • IS#1089 - Components should be allowed to have their own executor
  • IS#1088 - Add possibility to select a network interface for the ibverbs parcelport
  • IS#1087 - ibverbs and ipc parcelport uses zero copy optimization
  • IS#1083 - Make shell examples copyable in docs
  • IS#1082 - Implement proper termination detection during shutdown
  • IS#1081 - Implement thread_specific_ptr for hpx::threads
  • IS#1072 - make install not working properly
  • IS#1070 - Complete quoting for parameters of some CMake commands
  • IS#1059 - Fix more unused variable warnings
  • IS#1051 - Implement when_each
  • IS#973 - Would like option to report hwloc bindings
  • IS#970 - Bad flags for Fortran compiler
  • IS#941 - Create a proper user level context switching class for BG/Q
  • IS#935 - Build error with gcc 4.6 and Boost 1.54.0 on hpx trunk and 0.9.6
  • IS#934 - Want to build HPX without dynamic libraries
  • IS#927 - Make hpx/lcos/reduce.hpp accept futures of id_type
  • IS#926 - All unit tests that are run with more than one thread with CTest/hpx_run_test should configure hpx.os_threads
  • IS#925 - regression_dataflow_791 needs to be brought in line with HPX standards
  • IS#899 - Fix race conditions in regression tests
  • IS#879 - Hung test leads to cascading test failure; make tests should support the MPI parcelport
  • IS#865 - future<T> and friends shall work for movable only Ts
  • IS#847 - Dynamic libraries are not installed on OS X
  • IS#816 - First Program tutorial pull request
  • IS#799 - Wrap lexical_cast to avoid exceptions
  • IS#720 - broken configuration when using ccmake on Ubuntu
  • IS#622 - --hpx:hpx and --hpx:debug-hpx-log is nonsensical
  • IS#525 - Extend barrier LCO test to run in distributed
  • IS#515 - Multi-destination version of hpx::apply is broken
  • IS#509 - Push Boost.Atomic changes upstream
  • IS#503 - Running HPX applications on Windows should not require setting %PATH%
  • IS#461 - Add a compilation sanity test
  • IS#456 - hpx_run_tests.py should log output from tests that timeout
  • IS#454 - Investigate threadmanager performance
  • IS#345 - Add more versatile environmental/cmake variable support to hpx_find_* CMake macros
  • IS#209 - Support multiple configurations in generated build files
  • IS#190 - hpx::cout should be a std::ostream
  • IS#189 - iostreams component should use startup/shutdown functions
  • IS#183 - Use Boost.ICL for correctness in AGAS
  • IS#44 - Implement real futures

We have had over 800 commits since the last release and we have closed over 65 tickets (bugs, feature requests, etc.).

With the changes below, HPX is once again leading the charge of a whole new era of computation. By intrinsically breaking down and synchronizing the work to be done, HPX insures that application developers will no longer have to fret about where a segment of code executes. That allows coders to focus their time and energy to understanding the data dependencies of their algorithms and thereby the core obstacles to an efficient code. Here are some of the advantages of using HPX:

  • HPX is solidly rooted in a sophisticated theoretical execution model -- ParalleX
  • HPX exposes an API fully conforming to the C++11 and the draft C++14 standards, extended and applied to distributed computing. Everything programmers know about the concurrency primitives of the standard C++ library is still valid in the context of HPX.
  • It provides a competitive, high performance implementation of modern, future-proof ideas which gives an smooth migration path from todays mainstream techniques
  • There is no need for the programmer to worry about lower level parallelization paradigms like threads or message passing; no need to understand pthreads, MPI, OpenMP, or Windows threads, etc.
  • There is no need to think about different types of parallelism such as tasks, pipelines, or fork-join, task or data parallelism.
  • The same source of your program compiles and runs on Linux, BlueGene/Q, Mac OS X, Windows, and Android.
  • The same code runs on shared memory multi-core systems and supercomputers, on handheld devices and Intel Xeon Phi™ accelerators, or a heterogeneous mix of those.
General Changes
  • A major API breaking change for this release was introduced by implementing hpx::future and hpx::shared_future fully in conformance with the C++11 Standard. While hpx::shared_future is new and will not create any compatibility problems, we revised the interface and implementation of the existing hpx::future. For more details please see the mailing list archive. To avoid any incompatibilities for existing code we named the type which implements the std::future interface as hpx::unique_future. For the next release this will be renamed to hpx::future, making it full conforming to C++11 Standard.
  • A large part of the code base of HPX has been refactored and partially re-implemented. The main changes were related to
    • The threading subsystem: these changes significantly reduce the amount of overheads caused by the schedulers, improve the modularity of the code base, and extend the variety of available scheduling algorithms.
    • The parcel subsystem: these changes improve the performance of the HPX networking layer, modularize the structure of the parcelports, and simplify the creation of new parcelports for other underlying networking libraries.
    • The API subsystem: these changes improved the conformance of the API to C++11 Standard, extend and unify the available API functionality, and decrease the overheads created by various elements of the API.
    • The robustness of the component loading subsystem has been improved significantly, allowing to more portably and more reliably register the components needed by an application as startup. This additionally speeds up general application initialization.
  • We added new API functionality like hpx::migrate and hpx::copy_component which are the basic building blocks necessary for implementing higher level abstractions for system-wide load balancing, runtime-adaptive resource management, and object-oriented checkpointing and state-management.
  • We removed the use of C++11 move emulation (using Boost.Move), replacing it with C++11 rvalue references. This is the first step towards using more and more native C++11 facilities which we plan to introduce in the future.
  • We improved the reference counting scheme used by HPX which helps managing distributed objects and memory. This improves the overall stability of HPX and further simplifies writing real world applications.
  • The minimal Boost version required to use HPX is now V1.49.0.
  • This release coincides with the first release of HPXPI (V0.1.0), the first implementation of the XPI specification.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • IS#1086 - Expose internal boost::shared_array to allow user management of array lifetime
  • IS#1083 - Make shell examples copyable in docs
  • IS#1080 - /threads{locality#*/total}/count/cumulative broken
  • IS#1079 - Build problems on OS X
  • IS#1078 - Improve robustness of component loading
  • IS#1077 - Fix a missing enum definition for 'take' mode
  • IS#1076 - Merge Jb master
  • IS#1075 - Unknown CMake command "add_hpx_pseudo_target"
  • IS#1074 - Implement apply_continue_callback and apply_colocated_callback
  • IS#1073 - The new apply_colocated and async_colocated functions lead to automatic registered functions
  • IS#1071 - Remove deferred_packaged_task
  • IS#1069 - serialize_buffer with allocator fails at destruction
  • IS#1068 - Coroutine include and forward declarations missing
  • IS#1067 - Add allocator support to util::serialize_buffer
  • IS#1066 - Allow for MPI_Init being called before HPX launches
  • IS#1065 - AGAS cache isn't used/populated on worker localities
  • IS#1064 - Reorder includes to ensure ws2 includes early
  • IS#1063 - Add hpx::runtime::suspend and hpx::runtime::resume
  • IS#1062 - Fix async_continue to propery handle return types
  • IS#1061 - Implement async_colocated and apply_colocated
  • IS#1060 - Implement minimal component migration
  • IS#1058 - Remove HPX_UTIL_TUPLE from code base
  • IS#1057 - Add performance counters for threading subsystem
  • IS#1055 - Thread allocation uses two memory pools
  • IS#1053 - Work stealing flawed
  • IS#1052 - Fix a number of warnings
  • IS#1049 - Fixes for TLS on OSX and more reliable test running
  • IS#1048 - Fixing after 588 hang
  • IS#1047 - Use port '0' for networking when using one locality
  • IS#1046 - composable_guard test is broken when having more than one thread
  • IS#1045 - Security missing headers
  • IS#1044 - Native TLS on FreeBSD via __thread
  • IS#1043 - async et.al. compute the wrong result type
  • IS#1042 - async et.al. implicitly unwrap reference_wrappers
  • IS#1041 - Remove redundant costly Kleene stars from regex searches
  • IS#1040 - CMake script regex match patterns has unnecessary kleenes
  • IS#1039 - Remove use of Boost.Move and replace with std::move and real rvalue refs
  • IS#1038 - Bump minimal required Boost to 1.49.0
  • IS#1037 - Implicit unwrapping of futures in async broken
  • IS#1036 - Scheduler hangs when user code attempts to "block" OS-threads
  • IS#1035 - Idle-rate counter always reports 100% idle rate
  • IS#1034 - Symbolic name registration causes application hangs
  • IS#1033 - Application options read in from an options file generate an error message
  • IS#1032 - hpx::id_type local reference counting is wrong
  • IS#1031 - Negative entry in reference count table
  • IS#1030 - Implement condition_variable
  • IS#1029 - Deadlock in thread scheduling subsystem
  • IS#1028 - HPX-thread cumulative count performance counters report incorrect value
  • IS#1027 - Expose hpx::thread_interrupted error code as a separate exception type
  • IS#1026 - Exceptions thrown in asynchronous calls can be lost if the value of the future is never queried
  • IS#1025 - future::wait_for/wait_until do not remove callback
  • IS#1024 - Remove dependence to boost assert and create hpx assert
  • IS#1023 - Segfaults with tcmalloc
  • IS#1022 - prerequisites link in readme is broken
  • IS#1020 - HPX Deadlock on external synchronization
  • IS#1019 - Convert using BOOST_ASSERT to HPX_ASSERT
  • IS#1018 - compiling bug with gcc 4.8.1
  • IS#1017 - Possible crash in io_pool executor
  • IS#1016 - Crash at startup
  • IS#1014 - Implement Increment/Decrement Merging
  • IS#1013 - Add more logging channels to enable greater control over logging granularity
  • IS#1012 - --hpx:debug-hpx-log and --hpx:debug-agas-log lead to non-thread safe writes
  • IS#1011 - After installation, running applications from the build/staging directory no longer works
  • IS#1010 - Mergable decrement requests are not being merged
  • IS#1009 - --hpx:list-symbolic-names crashes
  • IS#1007 - Components are not properly destroyed
  • IS#1006 - Segfault/hang in set_data
  • IS#1003 - Performance counter naming issue
  • IS#982 - Race condition during startup
  • IS#912 - OS X: component type not found in map
  • IS#663 - Create a buildbot slave based on Clang 3.2/OSX
  • IS#636 - Expose this_locality::apply<act>(p1, p2); for local execution
  • IS#197 - Add --console=address option for PBS runs
  • IS#175 - Asynchronous AGAS API

We have had over 1000 commits since the last release and we have closed over 180 tickets (bugs, feature requests, etc.).

General Changes
  • Ported HPX to BlueGene/Q
  • Improved HPX support for Xeon/Phi accelerators
  • Reimplemented hpx::bind, hpx::tuple, and hpx::function for better performance and better compliance with the C++11 Standard. Added hpx::mem_fn.
  • Reworked hpx::when_all and hpx::when_any for better compliance with the ongoing C++ standardization effort, added heterogeneous version for those functions. Added hpx::when_any_swapped.
  • Added hpx::copy as a precursor for a migrate functionality
  • Added hpx::get_ptr allowing to directly access the memory underlying a given component
  • Added the hpx::lcos::broadcast, hpx::lcos::reduce, and hpx::lcos::fold collective operations
  • Added hpx::get_locality_name allowing to retrieve the name of any of the localities for the application.
  • Added support for more flexible thread affinity control from the HPX command line, such as new modes for --hpx:bind (balanced, scattered, compact), improved default settings when running multiple localities on the same node.
  • Added experimental executors for simpler thread pooling and scheduling. This API may change in the future as it will stay aligned with the ongoing C++ standardization efforts.
  • Massively improved the performance of the HPX serialization code. Added partial support for zero copy serialization of array and bitwise-copyable types.
  • General performance improvements of the code related to threads and futures.
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release.

  • IS#1005 - Allow to disable array optimizations and zero copy optimizations for each parcelport
  • IS#1004 - Generate new HPX logo image for the docs
  • IS#1002 - If MPI parcelport is not available, running HPX under mpirun should fail
  • IS#1001 - Zero copy serialization raises assert
  • IS#1000 - Can't connect to a HPX application running with the MPI parcelport from a non MPI parcelport locality
  • IS#999 - Optimize hpx::when_n
  • IS#998 - Fixed const-correctness
  • IS#997 - Making serialize_buffer::data() type save
  • IS#996 - Memory leak in hpx::lcos::promise
  • IS#995 - Race while registering pre-shutdown functions
  • IS#994 - thread_rescheduling regression test does not compile
  • IS#992 - Correct comments and messages
  • IS#991 - setcap cap_sys_rawio=ep for power profiling causes an HPX application to abort
  • IS#989 - Jacobi hangs during execution
  • IS#988 - multiple_init test is failing
  • IS#986 - Can't call a function called "init" from "main" when using <hpx/hpx_main.hpp>
  • IS#984 - Reference counting tests are failing
  • IS#983 - thread_suspension_executor test fails
  • IS#980 - Terminating HPX threads don't leave stack in virgin state
  • IS#979 - Static scheduler not in documents
  • IS#978 - Preprocessing limits are broken
  • IS#977 - Make tests.regressions.lcos.future_hang_on_get shorter
  • IS#976 - Wrong library order in pkgconfig
  • IS#975 - Please reopen #963
  • IS#974 - Option pu-offset ignored in fixing_588 branch
  • IS#972 - Cannot use MKL with HPX
  • IS#969 - Non-existent INI files requested on the command line via --hpx:config do not cause warnings or errors.
  • IS#968 - Cannot build examples in fixing_588 branch
  • IS#967 - Command line description of --hpx:queuing seems wrong
  • IS#966 - --hpx:print-bind physical core numbers are wrong
  • IS#965 - Deadlock when building in Release mode
  • IS#963 - Not all worker threads are working
  • IS#962 - Problem with SLURM integration
  • IS#961 - --hpx:print-bind outputs incorrect information
  • IS#960 - Fix cut and paste error in documentation of get_thread_priority
  • IS#959 - Change link to boost.atomic in documentation to point to boost.org
  • IS#958 - Undefined reference to intrusive_ptr_release
  • IS#957 - Make tuple standard compliant
  • IS#956 - Segfault with a3382fb
  • IS#955 - --hpx:nodes and --hpx:nodefiles do not work with foreign nodes
  • IS#954 - Make order of arguments for hpx::async and hpx::broadcast consistent
  • IS#953 - Cannot use MKL with HPX
  • IS#952 - register_[pre_]shutdown_function never throw
  • IS#951 - Assert when number of threads is greater than hardware concurrency
  • IS#947 - Need MPI_THREAD_MULTIPLE for backward compatibility
  • IS#946 - HPX does not call MPI_Finalize
  • IS#945 - Segfault with hpx::lcos::broadcast
  • IS#944 - OS X: assertion 'pu_offset_ < hardware_concurrency' failed
  • IS#943 - #include <hpx/hpx_main.hpp> does not work
  • IS#942 - Make the BG/Q work with -O3
  • IS#940 - Use separator when concatenating locality name
  • IS#939 - Refactor MPI parcelport to use MPI_Wait instead of multiple MPI_Test calls
  • IS#938 - Want to officially access client_base::gid_
  • IS#937 - client_base::gid_ should be private
  • IS#936 - Want doxygen-like source code index
  • IS#935 - Build error with gcc 4.6 and Boost 1.54.0 on hpx trunk and 0.9.6
  • IS#933 - Cannot build HPX with Boost 1.54.0
  • IS#932 - Components are destructed too early
  • IS#931 - Make HPX work on BG/Q
  • IS#930 - make git-docs is broken
  • IS#929 - Generating index in docs broken
  • IS#928 - Optimize hpx::util::static_ for C++11 compilers supporting magic statics
  • IS#924 - Make kill_process_tree (in process.py) more robust on Mac OSX
  • IS#923 - Correct BLAS and RNPL cmake tests
  • IS#922 - Cannot link against BLAS
  • IS#921 - Implement hpx::mem_fn
  • IS#920 - Output locality with --hpx:print-bind
  • IS#919 - Correct grammar; simplify boolean expressions
  • IS#918 - Link to hello_world.cpp is broken
  • IS#917 - adapt cmake file to new boostbook version
  • IS#916 - fix problem building documentation with xsltproc >= 1.1.27
  • IS#915 - Add another TBBMalloc library search path
  • IS#914 - Build problem with Intel compiler on Stampede (TACC)
  • IS#913 - fix error messages in fibonacci examples
  • IS#911 - Update OS X build instructions
  • IS#910 - Want like to specify MPI_ROOT instead of compiler wrapper script
  • IS#909 - Warning about void* arithmetic
  • IS#908 - Buildbot for MIC is broken
  • IS#906 - Can't use --hpx:bind=balanced with multiple MPI processes
  • IS#905 - --hpx:bind documentation should describe full grammar
  • IS#904 - Add hpx::lcos::fold and hpx::lcos::inverse_fold collective operation
  • IS#903 - Add hpx::when_any_swapped()
  • IS#902 - Add hpx::lcos::reduce collective operation
  • IS#901 - Web documentation is not searchable
  • IS#900 - Web documentation for trunk has no index
  • IS#898 - Some tests fail with GCC 4.8.1 and MPI parcel port
  • IS#897 - HWLOC causes failures on Mac
  • IS#896 - pu-offset leads to startup error
  • IS#895 - hpx::get_locality_name not defined
  • IS#894 - Race condition at shutdown
  • IS#893 - --hpx:print-bind switches std::cout to hexadecimal mode
  • IS#892 - hwloc_topology_load can be expensive -- don't call multiple times
  • IS#891 - The documentation for get_locality_name is wrong
  • IS#890 - --hpx:print-bind should not exit
  • IS#889 - --hpx:debug-hpx-log=FILE does not work
  • IS#888 - MPI parcelport does not exit cleanly for --hpx:print-bind
  • IS#887 - Choose thread affinities more cleverly
  • IS#886 - Logging documentation is confusing
  • IS#885 - Two threads are slower than one
  • IS#884 - is_callable failing with member pointers in C++11
  • IS#883 - Need help with is_callable_test
  • IS#882 - tests.regressions.lcos.future_hang_on_get does not terminate
  • IS#881 - tests/regressions/block_matrix/matrix.hh won't compile with GCC 4.8.1
  • IS#880 - HPX does not work on OS X
  • IS#878 - future::unwrap triggers assertion
  • IS#877 - "make tests" has build errors on Ubuntu 12.10
  • IS#876 - tcmalloc is used by default, even if it is not present
  • IS#875 - global_fixture is defined in a header file
  • IS#874 - Some tests take very long
  • IS#873 - Add block-matrix code as regression test
  • IS#872 - HPX documentation does not say how to run tests with detailed output
  • IS#871 - All tests fail with "make test"
  • IS#870 - Please explicitly disable serialization in classes that don't support it
  • IS#868 - boost_any test failing
  • IS#867 - Reduce the number of copies of hpx::function arguments
  • IS#863 - Futures should not require a default constructor
  • IS#862 - value_or_error shall not default construct its result
  • IS#861 - HPX_UNUSED macro
  • IS#860 - Add functionality to copy construct a component
  • IS#859 - hpx::endl should flush
  • IS#858 - Create hpx::get_ptr<> allowing to access component implementation
  • IS#855 - Implement hpx::INVOKE
  • IS#854 - hpx/hpx.hpp does not include hpx/include/iostreams.hpp
  • IS#853 - Feature request: null future
  • IS#852 - Feature request: Locality names
  • IS#851 - hpx::cout output does not appear on screen
  • IS#849 - All tests fail on OS X after installing
  • IS#848 - Update OS X build instructions
  • IS#846 - Update hpx_external_example
  • IS#845 - Issues with having both debug and release modules in the same directory
  • IS#844 - Create configuration header
  • IS#843 - Tests should use CTest
  • IS#842 - Remove buffer_pool from MPI parcelport
  • IS#841 - Add possibility to broadcast an index with hpx::lcos::broadcast
  • IS#838 - Simplify util::tuple
  • IS#837 - Adopt boost::tuple tests for util::tuple
  • IS#836 - Adopt boost::function tests for util::function
  • IS#835 - Tuple interface missing pieces
  • IS#833 - Partially preprocessing files not working
  • IS#832 - Native papi counters do not work with wild cards
  • IS#831 - Arithmetics counter fails if only one parameter is given
  • IS#830 - Convert hpx::util::function to use new scheme for serializing its base pointer
  • IS#829 - Consistently use decay<T> instead of remove_const< remove_reference<T>>
  • IS#828 - Update future implementation to N3721 and N3722
  • IS#827 - Enable MPI parcelport for bootstrapping whenever application was started using mpirun
  • IS#826 - Support command line option --hpx:print-bind even if --hpx::bind was not used
  • IS#825 - Memory counters give segfault when attempting to use thread wild cards or numbers only total works
  • IS#824 - Enable lambda functions to be used with hpx::async/hpx::apply
  • IS#823 - Using a hashing filter
  • IS#822 - Silence unused variable warning
  • IS#821 - Detect if a function object is callable with given arguments
  • IS#820 - Allow wildcards to be used for performance counter names
  • IS#819 - Make the AGAS symbolic name registry distributed
  • IS#818 - Add future::then() overload taking an executor
  • IS#817 - Fixed typo
  • IS#815 - Create an lco that is performing an efficient broadcast of actions
  • IS#814 - Papi counters cannot specify thread#* to get the counts for all threads
  • IS#813 - Scoped unlock
  • IS#811 - simple_central_tuplespace_client run error
  • IS#810 - ostream error when << any objects
  • IS#809 - Optimize parcel serialization
  • IS#808 - HPX applications throw exception when executed from the build directory
  • IS#807 - Create performance counters exposing overall AGAS statistics
  • IS#795 - Create timed make_ready_future
  • IS#794 - Create heterogeneous when_all/when_any/etc.
  • IS#721 - Make HPX usable for Xeon Phi
  • IS#694 - CMake should complain if you attempt to build an example without its dependencies
  • IS#692 - SLURM support broken
  • IS#683 - python/hpx/process.py imports epoll on all platforms
  • IS#619 - Automate the doc building process
  • IS#600 - GTC performance broken
  • IS#577 - Allow for zero copy serialization/networking
  • IS#551 - Change executable names to have debug postfix in Debug builds
  • IS#544 - Write a custom .lib file on Windows pulling in hpx_init and hpx.dll, phase out hpx_init
  • IS#534 - hpx::init should take functions by std::function and should accept all forms of hpx_main
  • IS#508 - FindPackage fails to set FOO_LIBRARY_DIR
  • IS#506 - Add cmake support to generate ini files for external applications
  • IS#470 - Changing build-type after configure does not update boost library names
  • IS#453 - Document hpx_run_tests.py
  • IS#445 - Significant performance mismatch between MPI and HPX in SMP for allgather example
  • IS#443 - Make docs viewable from build directory
  • IS#421 - Support multiple HPX instances per node in a batch environment like PBS or SLURM
  • IS#316 - Add message size limitation
  • IS#249 - Clean up locking code in big boot barrier
  • IS#136 - Persistent CMake variables need to be marked as cache variables

We have had over 1200 commits since the last release and we have closed roughly 140 tickets (bugs, feature requests, etc.).

General Changes

The major new fetures in this release are:

  • We further consolidated the API exposed by HPX. We aligned our APIs as much as possible with the existing C++11 Standard and related proposals to the C++ standardization committee (such as N3632 and N3857).
  • We implemented a first version of a distributed AGAS service which essentially eliminates all explicit AGAS network traffic.
  • We created a native ibverbs parcelport allowing to take advantage of the superior latency and bandwidth characteristics of Infiniband networks.
  • We successfully ported HPX to the Xeon Phi platform.
  • Support for the SLURM scheduling system was implemented.
  • Major efforts have been dedicated to improving the performance counter framework, numerous new counters were implemented and new APIs were added.
  • We added a modular parcel compression system allowing to improve bandwidth utilization (by reducing the overall size of the tranferred data).
  • We added a modular parcel coalescing system allowing to combine several parcels into larger messages. This reduces latencies introduced by the communication layer.
  • Added an experimental executors API allowing to use different scheduling policies for different parts of the code. This API has been modelled after the Standards proposal N3562. This API is bound to change in the future, though.
  • Added minimal security support for localities which is enforced on the parcelport level. This support is preliminary and experimental and might change in the future.
  • We created a parcelport using low level MPI functions. This is in support of legacy applications which are to be gradually ported and to support platforms where MPI is the only available portable networking layer.
  • We added a preliminary and experimental implementation of a tuple-space object which exposes an interface similar to such systems described in the literature (see for instance The Linda Coordination Language).
Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release. This is again a very long list of newly implemented features and fixed issues.

  • IS#806 - make (all) in examples folder does nothing
  • IS#805 - Adding the introduction and fixing DOCBOOK dependencies for Windows use
  • IS#804 - Add stackless (non-suspendable) thread type
  • IS#803 - Create proper serialization support functions for util::tuple
  • IS#800 - Add possibility to disable array optimizations during serialization
  • IS#798 - HPX_LIMIT does not work for local dataflow
  • IS#797 - Create a parcelport which uses MPI
  • IS#796 - Problem with Large Numbers of Threads
  • IS#793 - Changing dataflow test case to hang consistently
  • IS#792 - CMake Error
  • IS#791 - Problems with local::dataflow
  • IS#790 - wait_for() doesn't compile
  • IS#789 - HPX with Intel compiler segfaults
  • IS#788 - Intel compiler support
  • IS#787 - Fixed SFINAEd specializations
  • IS#786 - Memory issues during benchmarking.
  • IS#785 - Create an API allowing to register external threads with HPX
  • IS#784 - util::plugin is throwing an error when a symbol is not found
  • IS#783 - How does hpx:bind work?
  • IS#782 - Added quotes around STRING REPLACE potentially empty arguments
  • IS#781 - Make sure no exceptions propagate into the thread manager
  • IS#780 - Allow arithmetics performance counters to expand its parameters
  • IS#779 - Test case for 778
  • IS#778 - Swapping futures segfaults
  • IS#777 - hpx::lcos::details::when_xxx don't restore completion handlers
  • IS#776 - Compiler chokes on dataflow overload with launch policy
  • IS#775 - Runtime error with local dataflow (copying futures?)
  • IS#774 - Using local dataflow without explicit namespace
  • IS#773 - Local dataflow with unwrap: functor operators need to be const
  • IS#772 - Allow (remote) actions to return a future
  • IS#771 - Setting HPX_LIMIT gives huge boost MPL errors
  • IS#770 - Add launch policy to (local) dataflow
  • IS#769 - Make compile time configuration information available
  • IS#768 - Const correctness problem in local dataflow
  • IS#767 - Add launch policies to async
  • IS#766 - Mark data structures for optimized (array based) serialization
  • IS#765 - Align hpx::any with N3508: Any Library Proposal (Revision 2)
  • IS#764 - Align hpx::future with newest N3558: A Standardized Representation of Asynchronous Operations
  • IS#762 - added a human readable output for the ping pong example
  • IS#761 - Ambiguous typename when constructing derived component
  • IS#760 - Simple components can not be derived
  • IS#759 - make install doesn't give a complete install
  • IS#758 - Stack overflow when using locking_hook<>
  • IS#757 - copy paste error; unsupported function overloading
  • IS#756 - GTCX runtime issue in Gordon
  • IS#755 - Papi counters don't work with reset and evaluate API's
  • IS#753 - cmake bugfix and improved component action docs
  • IS#752 - hpx simple component docs
  • IS#750 - Add hpx::util::any
  • IS#749 - Thread phase counter is not reset
  • IS#748 - Memory performance counter are not registered
  • IS#747 - Create performance counters exposing arithmetic operations
  • IS#745 - apply_callback needs to invoke callback when applied locally
  • IS#744 - CMake fixes
  • IS#743 - Problem Building github version of HPX
  • IS#742 - Remove HPX_STD_BIND
  • IS#741 - assertion 'px != 0' failed: HPX(assertion_failure) for low numbers of OS threads
  • IS#739 - Performance counters do not count to the end of the program or evalution
  • IS#738 - Dedicated AGAS server runs don't work; console ignores -a option.
  • IS#737 - Missing bind overloads
  • IS#736 - Performance counter wildcards do not always work
  • IS#735 - Create native ibverbs parcelport based on rdma operations
  • IS#734 - Threads stolen performance counter total is incorrect
  • IS#733 - Test benchmarks need to be checked and fixed
  • IS#732 - Build fails with Mac, using mac ports clang-3.3 on latest git branch
  • IS#731 - Add global start/stop API for performance counters
  • IS#730 - Performance counter values are apparently incorrect
  • IS#729 - Unhandled switch
  • IS#728 - Serialization of hpx::util::function between two localities causes seg faults
  • IS#727 - Memory counters on Mac OS X
  • IS#725 - Restore original thread priority on resume
  • IS#724 - Performance benchmarks do not depend on main HPX libraries
  • IS#723 - --hpx:nodes=cat $PBS_NODEFILE works; --hpx:nodefile=$PBS_NODEFILE does not.
  • IS#722 - Fix binding const member functions as actions
  • IS#719 - Create performance counter exposing compression ratio
  • IS#718 - Add possibility to compress parcel data
  • IS#717 - strip_credit_from_gid has misleading semantics
  • IS#716 - Non-option arguments to programs run using pbsdsh must be before --hpx:nodes, contrary to directions
  • IS#715 - Re-thrown exceptions should retain the original call site
  • IS#714 - failed assertion in debug mode
  • IS#713 - Add performance counters monitoring connection caches
  • IS#712 - Adjust parcel related performance counters to be connection type specific
  • IS#711 - configuration failure
  • IS#710 - Error "timed out while trying to find room in the connection cache" when trying to start multiple localities on a single computer
  • IS#709 - Add new thread state 'staged' referring to task descriptions
  • IS#708 - Detect/mitigate bad non-system installs of GCC on Redhat systems
  • IS#707 - Many examples do not link with Git HEAD version
  • IS#706 - hpx::init removes portions of non-option command line arguments before last = sign
  • IS#705 - Create rolling average and median aggregating performance counters
  • IS#704 - Create performance counter to expose thread queue waiting time
  • IS#703 - Add support to HPX build system to find librcrtool.a and related headers
  • IS#699 - Generalize instrumentation support
  • IS#698 - compilation failure with hwloc absent
  • IS#697 - Performance counter counts should be zero indexed
  • IS#696 - Distributed problem
  • IS#695 - Bad perf counter time printed
  • IS#693 - --help doesn't print component specific command line options
  • IS#692 - SLURM support broken
  • IS#691 - exception while executing any application linked with hwloc
  • IS#690 - thread_id_test and thread_launcher_test failing
  • IS#689 - Make the buildbots use hwloc
  • IS#687 - compilation error fix (hwloc_topology)
  • IS#686 - Linker Error for Applications
  • IS#684 - Pinning of service thread fails when number of worker threads equals the number of cores
  • IS#682 - Add performance counters exposing number of stolen threads
  • IS#681 - Add apply_continue for asynchronous chaining of actions
  • IS#679 - Remove obsolete async_callback API functions
  • IS#678 - Add new API for setting/triggering LCOs
  • IS#677 - Add async_continue for true continuation style actions
  • IS#676 - Buildbot for gcc 4.4 broken
  • IS#675 - Partial preprocessing broken
  • IS#674 - HPX segfaults when built with gcc 4.7
  • IS#673 - use_guard_pages has inconsistent preprocessor guards
  • IS#672 - External build breaks if library path has spaces
  • IS#671 - release tarballs are tarbombs
  • IS#670 - CMake won't find Boost headers in layout=versioned install
  • IS#669 - Links in docs to source files broken if not installed
  • IS#667 - Not reading ini file properly
  • IS#664 - Adapt new meanings of 'const' and 'mutable'
  • IS#661 - Implement BTL Parcel port
  • IS#655 - Make HPX work with the "decltype" result_of
  • IS#647 - documentation for specifying the number of high priority threads --hpx:high-priority-threads
  • IS#643 - Error parsing host file
  • IS#642 - HWLoc issue with TAU
  • IS#639 - Logging potentially suspends a running thread
  • IS#634 - Improve error reporting from parcel layer
  • IS#627 - Add tests for async and apply overloads that accept regular C++ functions
  • IS#626 - hpx/future.hpp header
  • IS#601 - Intel support
  • IS#557 - Remove action codes
  • IS#531 - AGAS request and response classes should use switch statements
  • IS#529 - Investigate the state of hwloc support
  • IS#526 - Make HPX aware of hyper-threading
  • IS#518 - Create facilities allowing to use plain arrays as action arguments
  • IS#473 - hwloc thread binding is broken on CPUs with hyperthreading
  • IS#383 - Change result type detection for hpx::util::bind to use result_of protocol
  • IS#341 - Consolidate route code
  • IS#219 - Only copy arguments into actions once
  • IS#177 - Implement distributed AGAS
  • IS#43 - Support for Darwin (Xcode + Clang)

We have had over 1000 commits since the last release and we have closed roughly 150 tickets (bugs, feature requests, etc.).

General Changes

This release is continuing along the lines of code and API consolidation, and overall usability inprovements. We dedicated much attention to performance and we were able to significantly improve the threading and networking subsystems.

We successfully ported HPX to the Android platform. HPX applications now not only can run on mobile devices, but we support heterogeneous applications running across architecture boundaries. At the Supercomputing Conference 2012 we demonstrated connecting Android tablets to simulations running on a Linux cluster. The Android tablet was used to query performance counters from the Linux simulation and to steer its parameters.

We successfully ported HPX to Mac OSX (using the Clang compiler). Thanks to Pyry Jahkola for contributing the corresponding patches. Please see the section How to Install HPX on Mac OS for more details.

We made a special effort to make HPX usable in highly concurrent use cases. Many of the HPX API functions which possibly take longer than 100 microseconds to execute now can be invoked asynchronously. We added uniform support for composing futures which simplifies to write asynchronous code. HPX actions (function objects encapsulating possibly concurrent remote function invocations) are now well integrated with all other API facilities such like hpx::bind.

All of the API has been aligned as much as possible with established paradigms. HPX now mirrors many of the facilities as defined in the C++11 Standard, such as hpx::thread, hpx::function, hpx::future, etc.

A lot of work has been put into improving the documentation. Many of the API functions are documented now, concepts are explained in detail, and examples are better described than before. The new documentation index enables finding information with lesser effort.

This is the first release of HPX we perform after the move to Github. This step has enabled a wider participation from the community and further encourages us in our decision to release HPX as a true open source library (HPX is licensed under the very liberal Boost Software License).

Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release. This is by far the longest list of newly implemented features and fixed issues for any of HPX' releases so far.

  • IS#666 - Segfault on calling hpx::finalize twice
  • IS#665 - Adding declaration num_of_cores
  • IS#662 - pkgconfig is building wrong
  • IS#660 - Need uninterrupt function
  • IS#659 - Move our logging library into a different namespace
  • IS#658 - Dynamic performance counter types are broken
  • IS#657 - HPX v0.9.5 (RC1) hello_world example segfaulting
  • IS#656 - Define the affinity of parcel-pool, io-pool, and timer-pool threads
  • IS#654 - Integrate the Boost auto_index tool with documentation
  • IS#653 - Make HPX build on OS X + Clang + libc++
  • IS#651 - Add fine-grained control for thread pinning
  • IS#650 - Command line no error message when using -hpx:(anything)
  • IS#645 - Command line aliases don't work in @file
  • IS#644 - Terminated threads are not always properly cleaned up
  • IS#640 - future_data<T>::set_on_completed_ used without locks
  • IS#638 - hpx build with intel compilers fails on linux
  • IS#637 - --copy-dt-needed-entries breaks with gold
  • IS#635 - Boost V1.53 will add Boost.Lockfree and Boost.Atomic
  • IS#633 - Re-add examples to final 0.9.5 release
  • IS#632 - Example thread_aware_timer is broken
  • IS#631 - FFT application throws error in parcellayer
  • IS#630 - Event synchronization example is broken
  • IS#629 - Waiting on futures hangs
  • IS#628 - Add an HPX_ALWAYS_ASSERT macro
  • IS#625 - Port coroutines context switch benchmark
  • IS#621 - New INI section for stack sizes
  • IS#618 - pkg_config support does not work with a HPX debug build
  • IS#617 - hpx/external/logging/boost/logging/detail/cache_before_init.hpp:139:67: error: 'get_thread_id' was not declared in this scope
  • IS#616 - Change wait_xxx not to use locking
  • IS#615 - Revert visibility 'fix' (fb0b6b8245dad1127b0c25ebafd9386b3945cca9)
  • IS#614 - Fix Dataflow linker error
  • IS#613 - find_here should throw an exception on failure
  • IS#612 - Thread phase doesn't show up in debug mode
  • IS#611 - Make stack guard pages configurable at runtime (initialization time)
  • IS#610 - Co-Locate Components
  • IS#609 - future_overhead
  • IS#608 - --hpx:list-counter-infos problem
  • IS#607 - Update Boost.Context based backend for coroutines
  • IS#606 - 1d_wave_equation is not working
  • IS#605 - Any C++ function that has serializable arguments and a serializable return type should be remotable
  • IS#604 - Connecting localities isn't working anymore
  • IS#603 - Do not verify any ini entries read from a file
  • IS#602 - Rename argument_size to type_size/ added implementation to get parcel size
  • IS#599 - Enable locality specific command line options
  • IS#598 - Need an API that accesses the performance counter reporting the system uptime
  • IS#597 - compiling on ranger
  • IS#595 - I need a place to store data in a thread self pointer
  • IS#594 - 32/64 interoperability
  • IS#593 - Warn if logging is disabled at compile time but requested at runtime
  • IS#592 - Add optional argument value to --hpx:list-counters and --hpx:list-counter-infos
  • IS#591 - Allow for wildcards in performance counter names specified with --hpx:print-counter
  • IS#590 - Local promise semantic differences
  • IS#589 - Create API to query performance counter names
  • IS#587 - Add get_num_localities and get_num_threads to AGAS API
  • IS#586 - Adjust local AGAS cache size based on number of localities
  • IS#585 - Error while using counters in HPX
  • IS#584 - counting argument size of actions, initial pass.
  • IS#581 - Remove RemoteResult template parameter for future<>
  • IS#580 - Add possibility to hook into actions
  • IS#578 - Use angle brackets in HPX error dumps
  • IS#576 - Exception incorrectly thrown when --help is used
  • IS#575 - HPX(bad_component_type) with gcc 4.7.2 and boost 1.51
  • IS#574 - --hpx:connect command line parameter not working correctly
  • IS#571 - hpx::wait() (callback version) should pass the future to the callback function
  • IS#570 - hpx::wait should operate on boost::arrays and std::lists
  • IS#569 - Add a logging sink for Android
  • IS#568 - 2-argument version of HPX_DEFINE_COMPONENT_ACTION
  • IS#567 - Connecting to a running HPX application works only once
  • IS#565 - HPX doesn't shutdown properly
  • IS#564 - Partial preprocessing of new component creation interface
  • IS#563 - Add hpx::start/hpx::stop to avoid blocking main thread
  • IS#562 - All command line arguments swallowed by hpx
  • IS#561 - Boost.Tuple is not move aware
  • IS#558 - boost::shared_ptr<> style semantics/syntax for client classes
  • IS#556 - Creation of partially preprocessed headers should be enabled for Boost newer than V1.50
  • IS#555 - BOOST_FORCEINLINE does not name a type
  • IS#554 - Possible race condition in thread get_id()
  • IS#552 - Move enable client_base
  • IS#550 - Add stack size category 'huge'
  • IS#549 - ShenEOS run seg-faults on single or distributed runs
  • IS#545 - AUTOGLOB broken for add_hpx_component
  • IS#542 - FindHPX_HDF5 still searches multiple times
  • IS#541 - Quotes around application name in hpx::init
  • IS#539 - Race conditition occuring with new lightweight threads
  • IS#535 - hpx_run_tests.py exits with no error code when tests are missing
  • IS#530 - Thread description(<unknown>) in logs
  • IS#523 - Make thread objects more lightweight
  • IS#521 - hpx::error_code is not usable for lightweight error handling
  • IS#520 - Add full user environment to HPX logs
  • IS#519 - Build succeeds, running fails
  • IS#517 - Add a guard page to linux coroutine stacks
  • IS#516 - hpx::thread::detach suspends while holding locks, leads to hang in debug
  • IS#514 - Preprocessed headers for <hpx/apply.hpp> don't compile
  • IS#513 - Buildbot configuration problem
  • IS#512 - Implement action based stack size customization
  • IS#511 - Move action priority into a separate type trait
  • IS#510 - trunk broken
  • IS#507 - no matching function for call to boost::scoped_ptr<hpx::threads::topology>::scoped_ptr(hpx::threads::linux_topology*)
  • IS#505 - undefined_symbol regression test currently failing
  • IS#502 - Adding OpenCL and OCLM support to HPX for Windows and Linux
  • IS#501 - find_package(HPX) sets cmake output variables
  • IS#500 - wait_any/wait_all are badly named
  • IS#499 - Add support for disabling pbs support in pbs runs
  • IS#498 - Error during no-cache runs
  • IS#496 - Add partial preprocessing support to cmake
  • IS#495 - Support HPX modules exporting startup/shutdown functions only
  • IS#494 - Allow modules to specify when to run startup/shutdown functions
  • IS#493 - Avoid constructing a string in make_success_code
  • IS#492 - Performance counter creation is no longer synchronized at startup
  • IS#491 - Performance counter creation is no longer synchronized at startup
  • IS#490 - Sheneos on_completed_bulk seg fault in distributed
  • IS#489 - compiling issue with g++44
  • IS#488 - Adding OpenCL and OCLM support to HPX for the MSVC platform
  • IS#487 - FindHPX.cmake problems
  • IS#485 - Change distributing_factory and binpacking_factory to use bulk creation