Copy disabled (too large)
Download .txt
Showing preview only (20,742K chars total). Download the full file to get everything.
Repository: facebookincubator/Polygames
Branch: main
Commit: eb5390e57cc3
Files: 2575
Total size: 19.2 MB
Directory structure:
gitextract_jldjsds9/
├── .circleci/
│ └── config.yml
├── .clang-format
├── .github/
│ ├── CONTRIBUTING.md
│ ├── ISSUE_TEMPLATE.md
│ └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── build.sh
├── littlegolem/
│ └── play_littlegolem.py
├── nix/
│ ├── Dockerfile
│ ├── Dockerfile-centos7-nix
│ ├── README.md
│ ├── get-nvidia.sh
│ ├── shell-cpu.nix
│ └── shell-cuda.nix
├── pypolygames/
│ ├── __init__.py
│ ├── __main__.py
│ ├── convert.py
│ ├── draw_model.py
│ ├── env_creation_helpers.py
│ ├── evaluation.py
│ ├── human.py
│ ├── model_zoo/
│ │ ├── __init__.py
│ │ ├── amazons_model.py
│ │ ├── connect4_benchmark_model.py
│ │ ├── deep_conv_conv_logit_model.py
│ │ ├── deep_conv_fc_logit_model.py
│ │ ├── generic_model.py
│ │ ├── loss.py
│ │ ├── nano_conv_logit_model.py
│ │ ├── nano_fc_logit_model.py
│ │ ├── res_conv_conv_logit_model.py
│ │ ├── res_conv_conv_logit_pool_model.py
│ │ ├── res_conv_conv_logit_pool_model_v2.py
│ │ ├── res_conv_fc_logit_model.py
│ │ ├── u_conv_conv_logit_model.py
│ │ ├── u_conv_fc_logit_model.py
│ │ └── utils.py
│ ├── params.py
│ ├── tests/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── data/
│ │ │ ├── BlockGo.txt
│ │ │ ├── Breakthrough.txt
│ │ │ ├── ChineseCheckers.txt
│ │ │ ├── DiceShogi.txt
│ │ │ ├── Einstein.txt
│ │ │ ├── GameOfTheAmazons.txt
│ │ │ ├── Havannah5.txt
│ │ │ ├── Havannah8.txt
│ │ │ ├── Hex11.txt
│ │ │ ├── Hex13.txt
│ │ │ ├── KyotoShogi.txt
│ │ │ ├── Minishogi.txt
│ │ │ ├── Othello10.txt
│ │ │ ├── Othello16.txt
│ │ │ ├── OthelloOpt10.txt
│ │ │ ├── OthelloOpt16.txt
│ │ │ ├── Surakarta.txt
│ │ │ └── Tristannogo.txt
│ │ ├── test_interactions.py
│ │ ├── test_mcts.py
│ │ ├── test_params.py
│ │ └── test_zoo.py
│ ├── training.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── assert_utils.py
│ │ ├── checkpoint.py
│ │ ├── command_history.py
│ │ ├── helpers.py
│ │ ├── listings.py
│ │ ├── logger.py
│ │ ├── multi_counter.py
│ │ ├── plotter.py
│ │ ├── restrack.py
│ │ ├── result.py
│ │ └── test_listings.py
│ └── weight_init.py
├── singularity/
│ ├── README.md
│ ├── environment.yml
│ └── polygames.def
├── src/
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── async.h
│ │ ├── thread_id.cc
│ │ ├── thread_id.h
│ │ ├── threads.cc
│ │ └── threads.h
│ ├── core/
│ │ ├── actor.h
│ │ ├── actor_player.h
│ │ ├── forward_player.h
│ │ ├── game.cc
│ │ ├── game.h
│ │ ├── human_player.h
│ │ ├── model_manager.cc
│ │ ├── model_manager.h
│ │ ├── player.h
│ │ ├── pybind.cc
│ │ ├── replay_buffer.cc
│ │ ├── replay_buffer.h
│ │ ├── state.cc
│ │ ├── state.h
│ │ ├── test_state.cc
│ │ └── utils.h
│ ├── distributed/
│ │ ├── distributed.cc
│ │ ├── distributed.h
│ │ ├── ib.cc
│ │ ├── network.cc
│ │ ├── network.h
│ │ ├── rdma.h
│ │ ├── rdma_nop.cc
│ │ └── rpc.h
│ ├── games/
│ │ ├── amazons.cc
│ │ ├── amazons.h
│ │ ├── block_go.h
│ │ ├── breakthrough.cc
│ │ ├── breakthrough.h
│ │ ├── breakthrough_state.h
│ │ ├── chess.cc
│ │ ├── chess.h
│ │ ├── chinesecheckers.cc
│ │ ├── chinesecheckers.h
│ │ ├── chinesecheckers_defines.h
│ │ ├── commons/
│ │ │ ├── chessboard.h
│ │ │ ├── hash.h
│ │ │ └── player.h
│ │ ├── connect6.h
│ │ ├── connect6_state.h
│ │ ├── connectfour.h
│ │ ├── diceshogi.h
│ │ ├── diceshogi_state.h
│ │ ├── einstein.h
│ │ ├── game_action.h
│ │ ├── game_base.cc
│ │ ├── game_base.h
│ │ ├── game_player.h
│ │ ├── game_state.h
│ │ ├── gomoku_swap2.cc
│ │ ├── gomoku_swap2.h
│ │ ├── havannah.h
│ │ ├── havannah_state.h
│ │ ├── hex.h
│ │ ├── hex_state.h
│ │ ├── kyotoshogi.h
│ │ ├── kyotoshogi_state.h
│ │ ├── ludii/
│ │ │ ├── README.md
│ │ │ ├── jni_utils.cc
│ │ │ ├── jni_utils.h
│ │ │ ├── ludii_game_wrapper.cc
│ │ │ ├── ludii_game_wrapper.h
│ │ │ ├── ludii_state_wrapper.cc
│ │ │ └── ludii_state_wrapper.h
│ │ ├── mastermind_state.cc
│ │ ├── mastermind_state.h
│ │ ├── minesweeper.cc
│ │ ├── minesweeper_common.h
│ │ ├── minesweeper_csp_vkms/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ConnectedComponent.h
│ │ │ ├── CspStrategy.h
│ │ │ ├── SolutionSet.h
│ │ │ ├── SolutionSetSampler.h
│ │ │ └── csp_vkms.cc
│ │ ├── minesweeper_state.h
│ │ ├── minishogi.h
│ │ ├── mnkgame.h
│ │ ├── nogo_action.cc
│ │ ├── nogo_action.h
│ │ ├── nogo_bitboard.h
│ │ ├── nogo_game.cc
│ │ ├── nogo_game.h
│ │ ├── nogo_position.h
│ │ ├── nogo_state.cc
│ │ ├── nogo_state.h
│ │ ├── nogo_zestate.h
│ │ ├── othello.h
│ │ ├── othello_opt.cc
│ │ ├── othello_opt.h
│ │ ├── outeropengomoku_new.h
│ │ ├── shogi.h
│ │ ├── surakarta.h
│ │ ├── surakarta_state.h
│ │ ├── tristan_nogo.cc
│ │ ├── tristan_nogo.h
│ │ ├── tristannogo_state.h
│ │ ├── weakschur/
│ │ │ ├── SchurMatrix.cpp
│ │ │ ├── SchurMatrix.hpp
│ │ │ ├── SchurVector.cpp
│ │ │ ├── SchurVector.hpp
│ │ │ ├── WeakSchur.cpp
│ │ │ ├── WeakSchur.hpp
│ │ │ └── weakschur_state.h
│ │ ├── yinsh.cc
│ │ └── yinsh.h
│ ├── mcts/
│ │ ├── CMakeLists.txt
│ │ ├── actor.h
│ │ ├── mcts.cc
│ │ ├── mcts.h
│ │ ├── node.cc
│ │ ├── node.h
│ │ ├── player.h
│ │ ├── pybind.cc
│ │ ├── storage.cc
│ │ ├── storage.h
│ │ ├── test.cc
│ │ ├── types.h
│ │ └── utils.h
│ ├── third_party/
│ │ ├── asio/
│ │ │ ├── associated_allocator.hpp
│ │ │ ├── associated_executor.hpp
│ │ │ ├── async_result.hpp
│ │ │ ├── awaitable.hpp
│ │ │ ├── basic_datagram_socket.hpp
│ │ │ ├── basic_deadline_timer.hpp
│ │ │ ├── basic_io_object.hpp
│ │ │ ├── basic_raw_socket.hpp
│ │ │ ├── basic_seq_packet_socket.hpp
│ │ │ ├── basic_serial_port.hpp
│ │ │ ├── basic_signal_set.hpp
│ │ │ ├── basic_socket.hpp
│ │ │ ├── basic_socket_acceptor.hpp
│ │ │ ├── basic_socket_iostream.hpp
│ │ │ ├── basic_socket_streambuf.hpp
│ │ │ ├── basic_stream_socket.hpp
│ │ │ ├── basic_streambuf.hpp
│ │ │ ├── basic_streambuf_fwd.hpp
│ │ │ ├── basic_waitable_timer.hpp
│ │ │ ├── bind_executor.hpp
│ │ │ ├── buffer.hpp
│ │ │ ├── buffered_read_stream.hpp
│ │ │ ├── buffered_read_stream_fwd.hpp
│ │ │ ├── buffered_stream.hpp
│ │ │ ├── buffered_stream_fwd.hpp
│ │ │ ├── buffered_write_stream.hpp
│ │ │ ├── buffered_write_stream_fwd.hpp
│ │ │ ├── buffers_iterator.hpp
│ │ │ ├── co_spawn.hpp
│ │ │ ├── completion_condition.hpp
│ │ │ ├── compose.hpp
│ │ │ ├── connect.hpp
│ │ │ ├── coroutine.hpp
│ │ │ ├── deadline_timer.hpp
│ │ │ ├── defer.hpp
│ │ │ ├── detached.hpp
│ │ │ ├── detail/
│ │ │ │ ├── array.hpp
│ │ │ │ ├── array_fwd.hpp
│ │ │ │ ├── assert.hpp
│ │ │ │ ├── atomic_count.hpp
│ │ │ │ ├── base_from_completion_cond.hpp
│ │ │ │ ├── bind_handler.hpp
│ │ │ │ ├── buffer_resize_guard.hpp
│ │ │ │ ├── buffer_sequence_adapter.hpp
│ │ │ │ ├── buffered_stream_storage.hpp
│ │ │ │ ├── call_stack.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── chrono_time_traits.hpp
│ │ │ │ ├── completion_handler.hpp
│ │ │ │ ├── concurrency_hint.hpp
│ │ │ │ ├── conditionally_enabled_event.hpp
│ │ │ │ ├── conditionally_enabled_mutex.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── consuming_buffers.hpp
│ │ │ │ ├── cstddef.hpp
│ │ │ │ ├── cstdint.hpp
│ │ │ │ ├── date_time_fwd.hpp
│ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ ├── dependent_type.hpp
│ │ │ │ ├── descriptor_ops.hpp
│ │ │ │ ├── descriptor_read_op.hpp
│ │ │ │ ├── descriptor_write_op.hpp
│ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ ├── event.hpp
│ │ │ │ ├── eventfd_select_interrupter.hpp
│ │ │ │ ├── executor_function.hpp
│ │ │ │ ├── executor_op.hpp
│ │ │ │ ├── fd_set_adapter.hpp
│ │ │ │ ├── fenced_block.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── future.hpp
│ │ │ │ ├── gcc_arm_fenced_block.hpp
│ │ │ │ ├── gcc_hppa_fenced_block.hpp
│ │ │ │ ├── gcc_sync_fenced_block.hpp
│ │ │ │ ├── gcc_x86_fenced_block.hpp
│ │ │ │ ├── global.hpp
│ │ │ │ ├── handler_alloc_helpers.hpp
│ │ │ │ ├── handler_cont_helpers.hpp
│ │ │ │ ├── handler_invoke_helpers.hpp
│ │ │ │ ├── handler_tracking.hpp
│ │ │ │ ├── handler_type_requirements.hpp
│ │ │ │ ├── handler_work.hpp
│ │ │ │ ├── hash_map.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── buffer_sequence_adapter.ipp
│ │ │ │ │ ├── descriptor_ops.ipp
│ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ ├── dev_poll_reactor.ipp
│ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ ├── epoll_reactor.ipp
│ │ │ │ │ ├── eventfd_select_interrupter.ipp
│ │ │ │ │ ├── handler_tracking.ipp
│ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ ├── kqueue_reactor.ipp
│ │ │ │ │ ├── null_event.ipp
│ │ │ │ │ ├── pipe_select_interrupter.ipp
│ │ │ │ │ ├── posix_event.ipp
│ │ │ │ │ ├── posix_mutex.ipp
│ │ │ │ │ ├── posix_thread.ipp
│ │ │ │ │ ├── posix_tss_ptr.ipp
│ │ │ │ │ ├── reactive_descriptor_service.ipp
│ │ │ │ │ ├── reactive_serial_port_service.ipp
│ │ │ │ │ ├── reactive_socket_service_base.ipp
│ │ │ │ │ ├── resolver_service_base.ipp
│ │ │ │ │ ├── scheduler.ipp
│ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ ├── select_reactor.ipp
│ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ ├── service_registry.ipp
│ │ │ │ │ ├── signal_set_service.ipp
│ │ │ │ │ ├── socket_ops.ipp
│ │ │ │ │ ├── socket_select_interrupter.ipp
│ │ │ │ │ ├── strand_executor_service.hpp
│ │ │ │ │ ├── strand_executor_service.ipp
│ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ ├── strand_service.ipp
│ │ │ │ │ ├── throw_error.ipp
│ │ │ │ │ ├── timer_queue_ptime.ipp
│ │ │ │ │ ├── timer_queue_set.ipp
│ │ │ │ │ ├── win_event.ipp
│ │ │ │ │ ├── win_iocp_handle_service.ipp
│ │ │ │ │ ├── win_iocp_io_context.hpp
│ │ │ │ │ ├── win_iocp_io_context.ipp
│ │ │ │ │ ├── win_iocp_serial_port_service.ipp
│ │ │ │ │ ├── win_iocp_socket_service_base.ipp
│ │ │ │ │ ├── win_mutex.ipp
│ │ │ │ │ ├── win_object_handle_service.ipp
│ │ │ │ │ ├── win_static_mutex.ipp
│ │ │ │ │ ├── win_thread.ipp
│ │ │ │ │ ├── win_tss_ptr.ipp
│ │ │ │ │ ├── winrt_ssocket_service_base.ipp
│ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ ├── winrt_timer_scheduler.ipp
│ │ │ │ │ └── winsock_init.ipp
│ │ │ │ ├── io_control.hpp
│ │ │ │ ├── io_object_executor.hpp
│ │ │ │ ├── io_object_impl.hpp
│ │ │ │ ├── is_buffer_sequence.hpp
│ │ │ │ ├── is_executor.hpp
│ │ │ │ ├── keyword_tss_ptr.hpp
│ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ ├── limits.hpp
│ │ │ │ ├── local_free_on_block_exit.hpp
│ │ │ │ ├── macos_fenced_block.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── mutex.hpp
│ │ │ │ ├── non_const_lvalue.hpp
│ │ │ │ ├── noncopyable.hpp
│ │ │ │ ├── null_event.hpp
│ │ │ │ ├── null_fenced_block.hpp
│ │ │ │ ├── null_global.hpp
│ │ │ │ ├── null_mutex.hpp
│ │ │ │ ├── null_reactor.hpp
│ │ │ │ ├── null_signal_blocker.hpp
│ │ │ │ ├── null_socket_service.hpp
│ │ │ │ ├── null_static_mutex.hpp
│ │ │ │ ├── null_thread.hpp
│ │ │ │ ├── null_tss_ptr.hpp
│ │ │ │ ├── object_pool.hpp
│ │ │ │ ├── old_win_sdk_compat.hpp
│ │ │ │ ├── op_queue.hpp
│ │ │ │ ├── operation.hpp
│ │ │ │ ├── pipe_select_interrupter.hpp
│ │ │ │ ├── pop_options.hpp
│ │ │ │ ├── posix_event.hpp
│ │ │ │ ├── posix_fd_set_adapter.hpp
│ │ │ │ ├── posix_global.hpp
│ │ │ │ ├── posix_mutex.hpp
│ │ │ │ ├── posix_signal_blocker.hpp
│ │ │ │ ├── posix_static_mutex.hpp
│ │ │ │ ├── posix_thread.hpp
│ │ │ │ ├── posix_tss_ptr.hpp
│ │ │ │ ├── push_options.hpp
│ │ │ │ ├── reactive_descriptor_service.hpp
│ │ │ │ ├── reactive_null_buffers_op.hpp
│ │ │ │ ├── reactive_serial_port_service.hpp
│ │ │ │ ├── reactive_socket_accept_op.hpp
│ │ │ │ ├── reactive_socket_connect_op.hpp
│ │ │ │ ├── reactive_socket_recv_op.hpp
│ │ │ │ ├── reactive_socket_recvfrom_op.hpp
│ │ │ │ ├── reactive_socket_recvmsg_op.hpp
│ │ │ │ ├── reactive_socket_send_op.hpp
│ │ │ │ ├── reactive_socket_sendto_op.hpp
│ │ │ │ ├── reactive_socket_service.hpp
│ │ │ │ ├── reactive_socket_service_base.hpp
│ │ │ │ ├── reactive_wait_op.hpp
│ │ │ │ ├── reactor.hpp
│ │ │ │ ├── reactor_fwd.hpp
│ │ │ │ ├── reactor_op.hpp
│ │ │ │ ├── reactor_op_queue.hpp
│ │ │ │ ├── recycling_allocator.hpp
│ │ │ │ ├── regex_fwd.hpp
│ │ │ │ ├── resolve_endpoint_op.hpp
│ │ │ │ ├── resolve_op.hpp
│ │ │ │ ├── resolve_query_op.hpp
│ │ │ │ ├── resolver_service.hpp
│ │ │ │ ├── resolver_service_base.hpp
│ │ │ │ ├── scheduler.hpp
│ │ │ │ ├── scheduler_operation.hpp
│ │ │ │ ├── scheduler_thread_info.hpp
│ │ │ │ ├── scoped_lock.hpp
│ │ │ │ ├── scoped_ptr.hpp
│ │ │ │ ├── select_interrupter.hpp
│ │ │ │ ├── select_reactor.hpp
│ │ │ │ ├── service_registry.hpp
│ │ │ │ ├── signal_blocker.hpp
│ │ │ │ ├── signal_handler.hpp
│ │ │ │ ├── signal_init.hpp
│ │ │ │ ├── signal_op.hpp
│ │ │ │ ├── signal_set_service.hpp
│ │ │ │ ├── socket_holder.hpp
│ │ │ │ ├── socket_ops.hpp
│ │ │ │ ├── socket_option.hpp
│ │ │ │ ├── socket_select_interrupter.hpp
│ │ │ │ ├── socket_types.hpp
│ │ │ │ ├── solaris_fenced_block.hpp
│ │ │ │ ├── static_mutex.hpp
│ │ │ │ ├── std_event.hpp
│ │ │ │ ├── std_fenced_block.hpp
│ │ │ │ ├── std_global.hpp
│ │ │ │ ├── std_mutex.hpp
│ │ │ │ ├── std_static_mutex.hpp
│ │ │ │ ├── std_thread.hpp
│ │ │ │ ├── strand_executor_service.hpp
│ │ │ │ ├── strand_service.hpp
│ │ │ │ ├── string_view.hpp
│ │ │ │ ├── thread.hpp
│ │ │ │ ├── thread_context.hpp
│ │ │ │ ├── thread_group.hpp
│ │ │ │ ├── thread_info_base.hpp
│ │ │ │ ├── throw_error.hpp
│ │ │ │ ├── throw_exception.hpp
│ │ │ │ ├── timer_queue.hpp
│ │ │ │ ├── timer_queue_base.hpp
│ │ │ │ ├── timer_queue_ptime.hpp
│ │ │ │ ├── timer_queue_set.hpp
│ │ │ │ ├── timer_scheduler.hpp
│ │ │ │ ├── timer_scheduler_fwd.hpp
│ │ │ │ ├── tss_ptr.hpp
│ │ │ │ ├── type_traits.hpp
│ │ │ │ ├── variadic_templates.hpp
│ │ │ │ ├── wait_handler.hpp
│ │ │ │ ├── wait_op.hpp
│ │ │ │ ├── win_event.hpp
│ │ │ │ ├── win_fd_set_adapter.hpp
│ │ │ │ ├── win_fenced_block.hpp
│ │ │ │ ├── win_global.hpp
│ │ │ │ ├── win_iocp_handle_read_op.hpp
│ │ │ │ ├── win_iocp_handle_service.hpp
│ │ │ │ ├── win_iocp_handle_write_op.hpp
│ │ │ │ ├── win_iocp_io_context.hpp
│ │ │ │ ├── win_iocp_null_buffers_op.hpp
│ │ │ │ ├── win_iocp_operation.hpp
│ │ │ │ ├── win_iocp_overlapped_op.hpp
│ │ │ │ ├── win_iocp_overlapped_ptr.hpp
│ │ │ │ ├── win_iocp_serial_port_service.hpp
│ │ │ │ ├── win_iocp_socket_accept_op.hpp
│ │ │ │ ├── win_iocp_socket_connect_op.hpp
│ │ │ │ ├── win_iocp_socket_recv_op.hpp
│ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp
│ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp
│ │ │ │ ├── win_iocp_socket_send_op.hpp
│ │ │ │ ├── win_iocp_socket_service.hpp
│ │ │ │ ├── win_iocp_socket_service_base.hpp
│ │ │ │ ├── win_iocp_thread_info.hpp
│ │ │ │ ├── win_iocp_wait_op.hpp
│ │ │ │ ├── win_mutex.hpp
│ │ │ │ ├── win_object_handle_service.hpp
│ │ │ │ ├── win_static_mutex.hpp
│ │ │ │ ├── win_thread.hpp
│ │ │ │ ├── win_tss_ptr.hpp
│ │ │ │ ├── winapp_thread.hpp
│ │ │ │ ├── wince_thread.hpp
│ │ │ │ ├── winrt_async_manager.hpp
│ │ │ │ ├── winrt_async_op.hpp
│ │ │ │ ├── winrt_resolve_op.hpp
│ │ │ │ ├── winrt_resolver_service.hpp
│ │ │ │ ├── winrt_socket_connect_op.hpp
│ │ │ │ ├── winrt_socket_recv_op.hpp
│ │ │ │ ├── winrt_socket_send_op.hpp
│ │ │ │ ├── winrt_ssocket_service.hpp
│ │ │ │ ├── winrt_ssocket_service_base.hpp
│ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ ├── winrt_utils.hpp
│ │ │ │ ├── winsock_init.hpp
│ │ │ │ ├── work_dispatcher.hpp
│ │ │ │ └── wrapped_handler.hpp
│ │ │ ├── dispatch.hpp
│ │ │ ├── error.hpp
│ │ │ ├── error_code.hpp
│ │ │ ├── execution_context.hpp
│ │ │ ├── executor.hpp
│ │ │ ├── executor_work_guard.hpp
│ │ │ ├── generic/
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ └── impl/
│ │ │ │ │ └── endpoint.ipp
│ │ │ │ ├── raw_protocol.hpp
│ │ │ │ ├── seq_packet_protocol.hpp
│ │ │ │ └── stream_protocol.hpp
│ │ │ ├── handler_alloc_hook.hpp
│ │ │ ├── handler_continuation_hook.hpp
│ │ │ ├── handler_invoke_hook.hpp
│ │ │ ├── high_resolution_timer.hpp
│ │ │ ├── impl/
│ │ │ │ ├── awaitable.hpp
│ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ ├── co_spawn.hpp
│ │ │ │ ├── compose.hpp
│ │ │ │ ├── connect.hpp
│ │ │ │ ├── defer.hpp
│ │ │ │ ├── detached.hpp
│ │ │ │ ├── dispatch.hpp
│ │ │ │ ├── error.ipp
│ │ │ │ ├── error_code.ipp
│ │ │ │ ├── execution_context.hpp
│ │ │ │ ├── execution_context.ipp
│ │ │ │ ├── executor.hpp
│ │ │ │ ├── executor.ipp
│ │ │ │ ├── handler_alloc_hook.ipp
│ │ │ │ ├── io_context.hpp
│ │ │ │ ├── io_context.ipp
│ │ │ │ ├── post.hpp
│ │ │ │ ├── read.hpp
│ │ │ │ ├── read_at.hpp
│ │ │ │ ├── read_until.hpp
│ │ │ │ ├── redirect_error.hpp
│ │ │ │ ├── serial_port_base.hpp
│ │ │ │ ├── serial_port_base.ipp
│ │ │ │ ├── spawn.hpp
│ │ │ │ ├── src.cpp
│ │ │ │ ├── src.hpp
│ │ │ │ ├── system_context.hpp
│ │ │ │ ├── system_context.ipp
│ │ │ │ ├── system_executor.hpp
│ │ │ │ ├── thread_pool.hpp
│ │ │ │ ├── thread_pool.ipp
│ │ │ │ ├── use_awaitable.hpp
│ │ │ │ ├── use_future.hpp
│ │ │ │ ├── write.hpp
│ │ │ │ └── write_at.hpp
│ │ │ ├── io_context.hpp
│ │ │ ├── io_context_strand.hpp
│ │ │ ├── io_service.hpp
│ │ │ ├── io_service_strand.hpp
│ │ │ ├── ip/
│ │ │ │ ├── address.hpp
│ │ │ │ ├── address_v4.hpp
│ │ │ │ ├── address_v4_iterator.hpp
│ │ │ │ ├── address_v4_range.hpp
│ │ │ │ ├── address_v6.hpp
│ │ │ │ ├── address_v6_iterator.hpp
│ │ │ │ ├── address_v6_range.hpp
│ │ │ │ ├── bad_address_cast.hpp
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── basic_resolver.hpp
│ │ │ │ ├── basic_resolver_entry.hpp
│ │ │ │ ├── basic_resolver_iterator.hpp
│ │ │ │ ├── basic_resolver_query.hpp
│ │ │ │ ├── basic_resolver_results.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ └── socket_option.hpp
│ │ │ │ ├── host_name.hpp
│ │ │ │ ├── icmp.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── address.hpp
│ │ │ │ │ ├── address.ipp
│ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ ├── address_v4.ipp
│ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ ├── address_v6.ipp
│ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ ├── host_name.ipp
│ │ │ │ │ ├── network_v4.hpp
│ │ │ │ │ ├── network_v4.ipp
│ │ │ │ │ ├── network_v6.hpp
│ │ │ │ │ └── network_v6.ipp
│ │ │ │ ├── multicast.hpp
│ │ │ │ ├── network_v4.hpp
│ │ │ │ ├── network_v6.hpp
│ │ │ │ ├── resolver_base.hpp
│ │ │ │ ├── resolver_query_base.hpp
│ │ │ │ ├── tcp.hpp
│ │ │ │ ├── udp.hpp
│ │ │ │ ├── unicast.hpp
│ │ │ │ └── v6_only.hpp
│ │ │ ├── is_executor.hpp
│ │ │ ├── is_read_buffered.hpp
│ │ │ ├── is_write_buffered.hpp
│ │ │ ├── local/
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── connect_pair.hpp
│ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ └── impl/
│ │ │ │ │ └── endpoint.ipp
│ │ │ │ └── stream_protocol.hpp
│ │ │ ├── packaged_task.hpp
│ │ │ ├── placeholders.hpp
│ │ │ ├── posix/
│ │ │ │ ├── basic_descriptor.hpp
│ │ │ │ ├── basic_stream_descriptor.hpp
│ │ │ │ ├── descriptor.hpp
│ │ │ │ ├── descriptor_base.hpp
│ │ │ │ └── stream_descriptor.hpp
│ │ │ ├── post.hpp
│ │ │ ├── read.hpp
│ │ │ ├── read_at.hpp
│ │ │ ├── read_until.hpp
│ │ │ ├── redirect_error.hpp
│ │ │ ├── serial_port.hpp
│ │ │ ├── serial_port_base.hpp
│ │ │ ├── signal_set.hpp
│ │ │ ├── socket_base.hpp
│ │ │ ├── spawn.hpp
│ │ │ ├── ssl/
│ │ │ │ ├── context.hpp
│ │ │ │ ├── context_base.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── buffered_handshake_op.hpp
│ │ │ │ │ ├── engine.hpp
│ │ │ │ │ ├── handshake_op.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── engine.ipp
│ │ │ │ │ │ └── openssl_init.ipp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── openssl_init.hpp
│ │ │ │ │ ├── openssl_types.hpp
│ │ │ │ │ ├── password_callback.hpp
│ │ │ │ │ ├── read_op.hpp
│ │ │ │ │ ├── shutdown_op.hpp
│ │ │ │ │ ├── stream_core.hpp
│ │ │ │ │ ├── verify_callback.hpp
│ │ │ │ │ └── write_op.hpp
│ │ │ │ ├── error.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── context.ipp
│ │ │ │ │ ├── error.ipp
│ │ │ │ │ ├── rfc2818_verification.ipp
│ │ │ │ │ └── src.hpp
│ │ │ │ ├── rfc2818_verification.hpp
│ │ │ │ ├── stream.hpp
│ │ │ │ ├── stream_base.hpp
│ │ │ │ ├── verify_context.hpp
│ │ │ │ └── verify_mode.hpp
│ │ │ ├── ssl.hpp
│ │ │ ├── steady_timer.hpp
│ │ │ ├── strand.hpp
│ │ │ ├── streambuf.hpp
│ │ │ ├── system_context.hpp
│ │ │ ├── system_error.hpp
│ │ │ ├── system_executor.hpp
│ │ │ ├── system_timer.hpp
│ │ │ ├── this_coro.hpp
│ │ │ ├── thread.hpp
│ │ │ ├── thread_pool.hpp
│ │ │ ├── time_traits.hpp
│ │ │ ├── ts/
│ │ │ │ ├── buffer.hpp
│ │ │ │ ├── executor.hpp
│ │ │ │ ├── internet.hpp
│ │ │ │ ├── io_context.hpp
│ │ │ │ ├── net.hpp
│ │ │ │ ├── netfwd.hpp
│ │ │ │ ├── socket.hpp
│ │ │ │ └── timer.hpp
│ │ │ ├── unyield.hpp
│ │ │ ├── use_awaitable.hpp
│ │ │ ├── use_future.hpp
│ │ │ ├── uses_executor.hpp
│ │ │ ├── version.hpp
│ │ │ ├── wait_traits.hpp
│ │ │ ├── windows/
│ │ │ │ ├── basic_object_handle.hpp
│ │ │ │ ├── basic_overlapped_handle.hpp
│ │ │ │ ├── basic_random_access_handle.hpp
│ │ │ │ ├── basic_stream_handle.hpp
│ │ │ │ ├── object_handle.hpp
│ │ │ │ ├── overlapped_handle.hpp
│ │ │ │ ├── overlapped_ptr.hpp
│ │ │ │ ├── random_access_handle.hpp
│ │ │ │ └── stream_handle.hpp
│ │ │ ├── write.hpp
│ │ │ ├── write_at.hpp
│ │ │ └── yield.hpp
│ │ ├── asio.hpp
│ │ ├── concurrentqueue/
│ │ │ ├── LICENSE.md
│ │ │ ├── README.md
│ │ │ ├── benchmarks/
│ │ │ │ ├── benchmarks.cpp
│ │ │ │ ├── boost/
│ │ │ │ │ ├── LICENSE_1_0.txt
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── array.hpp
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── atomic/
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ ├── capabilities.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ │ ├── atomic_template.hpp
│ │ │ │ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ │ │ │ ├── caps_windows.hpp
│ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ ├── int_sizes.hpp
│ │ │ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ │ │ ├── link.hpp
│ │ │ │ │ │ │ ├── lockpool.hpp
│ │ │ │ │ │ │ ├── operations.hpp
│ │ │ │ │ │ │ ├── operations_fwd.hpp
│ │ │ │ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ │ │ │ ├── ops_emulated.hpp
│ │ │ │ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ │ │ │ ├── ops_windows.hpp
│ │ │ │ │ │ │ ├── pause.hpp
│ │ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ │ └── storage_type.hpp
│ │ │ │ │ │ └── fences.hpp
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── config/
│ │ │ │ │ │ ├── abi/
│ │ │ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ │ ├── compiler/
│ │ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ │ ├── clang.hpp
│ │ │ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ │ ├── kai.hpp
│ │ │ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ │ │ └── xlcpp.hpp
│ │ │ │ │ │ ├── no_tr1/
│ │ │ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ │ └── utility.hpp
│ │ │ │ │ │ ├── platform/
│ │ │ │ │ │ │ ├── aix.hpp
│ │ │ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ │ │ ├── beos.hpp
│ │ │ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ │ │ ├── irix.hpp
│ │ │ │ │ │ │ ├── linux.hpp
│ │ │ │ │ │ │ ├── macos.hpp
│ │ │ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ │ │ ├── vms.hpp
│ │ │ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ │ │ └── win32.hpp
│ │ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ │ ├── requires_threads.hpp
│ │ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ │ │ ├── modena.hpp
│ │ │ │ │ │ │ ├── msl.hpp
│ │ │ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ │ │ └── vacpp.hpp
│ │ │ │ │ │ ├── suffix.hpp
│ │ │ │ │ │ ├── user.hpp
│ │ │ │ │ │ └── warning_disable.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── core/
│ │ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ │ └── swap.hpp
│ │ │ │ │ ├── cstdint.hpp
│ │ │ │ │ ├── current_function.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── is_xxx.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ ├── exception/
│ │ │ │ │ │ └── exception.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── hash/
│ │ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ ├── limits.hpp
│ │ │ │ │ ├── lockfree/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ │ ├── copy_payload.hpp
│ │ │ │ │ │ │ ├── freelist.hpp
│ │ │ │ │ │ │ ├── parameter.hpp
│ │ │ │ │ │ │ ├── prefix.hpp
│ │ │ │ │ │ │ ├── tagged_ptr.hpp
│ │ │ │ │ │ │ ├── tagged_ptr_dcas.hpp
│ │ │ │ │ │ │ └── tagged_ptr_ptrcompression.hpp
│ │ │ │ │ │ ├── policies.hpp
│ │ │ │ │ │ └── queue.hpp
│ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ ├── mpl/
│ │ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ │ ├── O1_size_fwd.hpp
│ │ │ │ │ │ ├── always.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── arg_fwd.hpp
│ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ ├── at_fwd.hpp
│ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ ├── O1_size_impl.hpp
│ │ │ │ │ │ │ ├── adl_barrier.hpp
│ │ │ │ │ │ │ ├── arg_typedef.hpp
│ │ │ │ │ │ │ ├── arity.hpp
│ │ │ │ │ │ │ ├── arity_spec.hpp
│ │ │ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ │ │ ├── common_name_wknd.hpp
│ │ │ │ │ │ │ ├── config/
│ │ │ │ │ │ │ │ ├── adl.hpp
│ │ │ │ │ │ │ │ ├── arrays.hpp
│ │ │ │ │ │ │ │ ├── bcc.hpp
│ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ │ │ │ ├── ctps.hpp
│ │ │ │ │ │ │ │ ├── dmc_ambiguous_ctps.hpp
│ │ │ │ │ │ │ │ ├── dtp.hpp
│ │ │ │ │ │ │ │ ├── eti.hpp
│ │ │ │ │ │ │ │ ├── forwarding.hpp
│ │ │ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ │ │ ├── gpu.hpp
│ │ │ │ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ │ │ │ ├── integral.hpp
│ │ │ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ │ │ ├── msvc.hpp
│ │ │ │ │ │ │ │ ├── msvc_typename.hpp
│ │ │ │ │ │ │ │ ├── nttp.hpp
│ │ │ │ │ │ │ │ ├── operators.hpp
│ │ │ │ │ │ │ │ ├── overload_resolution.hpp
│ │ │ │ │ │ │ │ ├── pp_counter.hpp
│ │ │ │ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ │ │ │ ├── static_constant.hpp
│ │ │ │ │ │ │ │ ├── ttp.hpp
│ │ │ │ │ │ │ │ ├── use_preprocessed.hpp
│ │ │ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ │ │ ├── count_args.hpp
│ │ │ │ │ │ │ ├── find_if_pred.hpp
│ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ ├── fold_impl_body.hpp
│ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ │ │ ├── has_begin.hpp
│ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ ├── has_rebind.hpp
│ │ │ │ │ │ │ ├── has_size.hpp
│ │ │ │ │ │ │ ├── has_tag.hpp
│ │ │ │ │ │ │ ├── has_type.hpp
│ │ │ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ │ │ ├── integral_wrapper.hpp
│ │ │ │ │ │ │ ├── is_msvc_eti_arg.hpp
│ │ │ │ │ │ │ ├── iter_apply.hpp
│ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ ├── lambda_arity_param.hpp
│ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ ├── lambda_spec.hpp
│ │ │ │ │ │ │ ├── lambda_support.hpp
│ │ │ │ │ │ │ ├── logical_op.hpp
│ │ │ │ │ │ │ ├── msvc_dtw.hpp
│ │ │ │ │ │ │ ├── msvc_eti_base.hpp
│ │ │ │ │ │ │ ├── msvc_is_class.hpp
│ │ │ │ │ │ │ ├── msvc_never_true.hpp
│ │ │ │ │ │ │ ├── msvc_type.hpp
│ │ │ │ │ │ │ ├── na.hpp
│ │ │ │ │ │ │ ├── na_assert.hpp
│ │ │ │ │ │ │ ├── na_fwd.hpp
│ │ │ │ │ │ │ ├── na_spec.hpp
│ │ │ │ │ │ │ ├── nested_type_wknd.hpp
│ │ │ │ │ │ │ ├── nttp_decl.hpp
│ │ │ │ │ │ │ ├── overload_names.hpp
│ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ ├── bcc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── bcc551/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── bcc_pre590/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── gcc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── msvc60/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── msvc70/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── mwcw/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── no_ctps/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── no_ttp/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ └── plain/
│ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ ├── add.hpp
│ │ │ │ │ │ │ │ ├── def_params_tail.hpp
│ │ │ │ │ │ │ │ ├── default_params.hpp
│ │ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ │ ├── ext_params.hpp
│ │ │ │ │ │ │ │ ├── filter_params.hpp
│ │ │ │ │ │ │ │ ├── params.hpp
│ │ │ │ │ │ │ │ ├── partial_spec_params.hpp
│ │ │ │ │ │ │ │ ├── range.hpp
│ │ │ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ │ │ ├── sub.hpp
│ │ │ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ │ │ ├── ptr_to_ref.hpp
│ │ │ │ │ │ │ ├── push_front_impl.hpp
│ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ ├── reverse_fold_impl_body.hpp
│ │ │ │ │ │ │ ├── sequence_wrapper.hpp
│ │ │ │ │ │ │ ├── static_cast.hpp
│ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ ├── template_arity_fwd.hpp
│ │ │ │ │ │ │ ├── traits_lambda_spec.hpp
│ │ │ │ │ │ │ ├── type_wrapper.hpp
│ │ │ │ │ │ │ ├── value_wknd.hpp
│ │ │ │ │ │ │ └── yes_no.hpp
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ │ ├── begin_end_fwd.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bool.hpp
│ │ │ │ │ │ ├── bool_fwd.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── clear_fwd.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── empty_fwd.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── erase_fwd.hpp
│ │ │ │ │ │ ├── erase_key_fwd.hpp
│ │ │ │ │ │ ├── eval_if.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ ├── front_fwd.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── has_key_fwd.hpp
│ │ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── if.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_fwd.hpp
│ │ │ │ │ │ ├── insert_range_fwd.hpp
│ │ │ │ │ │ ├── int.hpp
│ │ │ │ │ │ ├── int_fwd.hpp
│ │ │ │ │ │ ├── integral_c.hpp
│ │ │ │ │ │ ├── integral_c_fwd.hpp
│ │ │ │ │ │ ├── integral_c_tag.hpp
│ │ │ │ │ │ ├── is_placeholder.hpp
│ │ │ │ │ │ ├── iter_fold_if.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── iterator_tags.hpp
│ │ │ │ │ │ ├── key_type_fwd.hpp
│ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ ├── lambda_fwd.hpp
│ │ │ │ │ │ ├── limits/
│ │ │ │ │ │ │ ├── arity.hpp
│ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ └── unrolling.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ │ │ │ ├── item.hpp
│ │ │ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ │ │ ├── numbered.hpp
│ │ │ │ │ │ │ │ ├── numbered_c.hpp
│ │ │ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ └── plain/
│ │ │ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ │ └── tag.hpp
│ │ │ │ │ │ │ ├── list0.hpp
│ │ │ │ │ │ │ ├── list0_c.hpp
│ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── logical.hpp
│ │ │ │ │ │ ├── long.hpp
│ │ │ │ │ │ ├── long_fwd.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── next_prior.hpp
│ │ │ │ │ │ ├── not.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── pop_front_fwd.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── protect.hpp
│ │ │ │ │ │ ├── push_back_fwd.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ ├── push_front_fwd.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ ├── same_as.hpp
│ │ │ │ │ │ ├── sequence_tag.hpp
│ │ │ │ │ │ ├── sequence_tag_fwd.hpp
│ │ │ │ │ │ ├── set/
│ │ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── erase_impl.hpp
│ │ │ │ │ │ │ │ ├── erase_key_impl.hpp
│ │ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ │ │ │ ├── insert_range_impl.hpp
│ │ │ │ │ │ │ │ ├── item.hpp
│ │ │ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ │ │ ├── key_type_impl.hpp
│ │ │ │ │ │ │ │ ├── set0.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── tag.hpp
│ │ │ │ │ │ │ │ └── value_type_impl.hpp
│ │ │ │ │ │ │ └── set0.hpp
│ │ │ │ │ │ ├── size_fwd.hpp
│ │ │ │ │ │ ├── size_t.hpp
│ │ │ │ │ │ ├── size_t_fwd.hpp
│ │ │ │ │ │ ├── value_type_fwd.hpp
│ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ └── void_fwd.hpp
│ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ ├── parameter/
│ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ ├── arg_list.hpp
│ │ │ │ │ │ │ ├── cast.hpp
│ │ │ │ │ │ │ ├── default.hpp
│ │ │ │ │ │ │ ├── is_maybe.hpp
│ │ │ │ │ │ │ ├── overloads.hpp
│ │ │ │ │ │ │ ├── parameter_requirements.hpp
│ │ │ │ │ │ │ ├── parenthesized_type.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ │ │ └── for_each.hpp
│ │ │ │ │ │ │ ├── result_of0.hpp
│ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ ├── tag.hpp
│ │ │ │ │ │ │ ├── tagged_argument.hpp
│ │ │ │ │ │ │ ├── template_keyword.hpp
│ │ │ │ │ │ │ ├── unwrap_cv_reference.hpp
│ │ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ │ └── yesno.hpp
│ │ │ │ │ │ ├── binding.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── keyword.hpp
│ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ ├── match.hpp
│ │ │ │ │ │ ├── name.hpp
│ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ │ └── value_type.hpp
│ │ │ │ │ ├── parameter.hpp
│ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ │ ├── add.hpp
│ │ │ │ │ │ │ ├── dec.hpp
│ │ │ │ │ │ │ ├── inc.hpp
│ │ │ │ │ │ │ └── sub.hpp
│ │ │ │ │ │ ├── array/
│ │ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ └── size.hpp
│ │ │ │ │ │ ├── cat.hpp
│ │ │ │ │ │ ├── comma_if.hpp
│ │ │ │ │ │ ├── comparison/
│ │ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ └── not_equal.hpp
│ │ │ │ │ │ ├── config/
│ │ │ │ │ │ │ └── config.hpp
│ │ │ │ │ │ ├── control/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ ├── msvc/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ ├── expr_if.hpp
│ │ │ │ │ │ │ ├── expr_iif.hpp
│ │ │ │ │ │ │ ├── if.hpp
│ │ │ │ │ │ │ ├── iif.hpp
│ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ ├── debug/
│ │ │ │ │ │ │ └── error.hpp
│ │ │ │ │ │ ├── dec.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── auto_rec.hpp
│ │ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ └── auto_rec.hpp
│ │ │ │ │ │ │ ├── is_binary.hpp
│ │ │ │ │ │ │ ├── is_nullary.hpp
│ │ │ │ │ │ │ └── split.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ ├── enum_params.hpp
│ │ │ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ │ │ ├── expr_if.hpp
│ │ │ │ │ │ ├── facilities/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_empty.hpp
│ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ ├── expand.hpp
│ │ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ │ ├── intercept.hpp
│ │ │ │ │ │ │ ├── is_1.hpp
│ │ │ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ │ │ ├── is_empty_variadic.hpp
│ │ │ │ │ │ │ └── overload.hpp
│ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── inc.hpp
│ │ │ │ │ │ ├── iterate.hpp
│ │ │ │ │ │ ├── iteration/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── bounds/
│ │ │ │ │ │ │ │ │ ├── lower1.hpp
│ │ │ │ │ │ │ │ │ ├── lower2.hpp
│ │ │ │ │ │ │ │ │ ├── lower3.hpp
│ │ │ │ │ │ │ │ │ ├── lower4.hpp
│ │ │ │ │ │ │ │ │ ├── lower5.hpp
│ │ │ │ │ │ │ │ │ ├── upper1.hpp
│ │ │ │ │ │ │ │ │ ├── upper2.hpp
│ │ │ │ │ │ │ │ │ ├── upper3.hpp
│ │ │ │ │ │ │ │ │ ├── upper4.hpp
│ │ │ │ │ │ │ │ │ └── upper5.hpp
│ │ │ │ │ │ │ │ ├── finish.hpp
│ │ │ │ │ │ │ │ ├── iter/
│ │ │ │ │ │ │ │ │ ├── forward1.hpp
│ │ │ │ │ │ │ │ │ ├── forward2.hpp
│ │ │ │ │ │ │ │ │ ├── forward3.hpp
│ │ │ │ │ │ │ │ │ ├── forward4.hpp
│ │ │ │ │ │ │ │ │ ├── forward5.hpp
│ │ │ │ │ │ │ │ │ ├── reverse1.hpp
│ │ │ │ │ │ │ │ │ ├── reverse2.hpp
│ │ │ │ │ │ │ │ │ ├── reverse3.hpp
│ │ │ │ │ │ │ │ │ ├── reverse4.hpp
│ │ │ │ │ │ │ │ │ └── reverse5.hpp
│ │ │ │ │ │ │ │ ├── local.hpp
│ │ │ │ │ │ │ │ ├── rlocal.hpp
│ │ │ │ │ │ │ │ ├── self.hpp
│ │ │ │ │ │ │ │ └── start.hpp
│ │ │ │ │ │ │ ├── iterate.hpp
│ │ │ │ │ │ │ ├── local.hpp
│ │ │ │ │ │ │ └── self.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── adt.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── fold_left.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ ├── fold_right.hpp
│ │ │ │ │ │ │ ├── for_each_i.hpp
│ │ │ │ │ │ │ └── reverse.hpp
│ │ │ │ │ │ ├── logical/
│ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ ├── bool.hpp
│ │ │ │ │ │ │ ├── compl.hpp
│ │ │ │ │ │ │ └── not.hpp
│ │ │ │ │ │ ├── punctuation/
│ │ │ │ │ │ │ ├── comma.hpp
│ │ │ │ │ │ │ ├── comma_if.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ ├── repetition/
│ │ │ │ │ │ │ ├── deduce_r.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ │ │ └── msvc/
│ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ ├── enum_binary_params.hpp
│ │ │ │ │ │ │ ├── enum_params.hpp
│ │ │ │ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ │ │ │ ├── enum_shifted.hpp
│ │ │ │ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ │ │ │ ├── enum_trailing.hpp
│ │ │ │ │ │ │ ├── enum_trailing_params.hpp
│ │ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ │ └── repeat_from_to.hpp
│ │ │ │ │ │ ├── selection/
│ │ │ │ │ │ │ └── max.hpp
│ │ │ │ │ │ ├── seq/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ │ │ │ └── split.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ ├── first_n.hpp
│ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ ├── for_each_i.hpp
│ │ │ │ │ │ │ ├── for_each_product.hpp
│ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ ├── rest_n.hpp
│ │ │ │ │ │ │ ├── seq.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ └── subseq.hpp
│ │ │ │ │ │ ├── slot/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── counter.hpp
│ │ │ │ │ │ │ │ ├── def.hpp
│ │ │ │ │ │ │ │ ├── shared.hpp
│ │ │ │ │ │ │ │ ├── slot1.hpp
│ │ │ │ │ │ │ │ ├── slot2.hpp
│ │ │ │ │ │ │ │ ├── slot3.hpp
│ │ │ │ │ │ │ │ ├── slot4.hpp
│ │ │ │ │ │ │ │ └── slot5.hpp
│ │ │ │ │ │ │ └── slot.hpp
│ │ │ │ │ │ ├── stringize.hpp
│ │ │ │ │ │ ├── tuple/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_single_return.hpp
│ │ │ │ │ │ │ ├── eat.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ ├── rem.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ └── to_list.hpp
│ │ │ │ │ │ └── variadic/
│ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ └── size.hpp
│ │ │ │ │ ├── static_assert.hpp
│ │ │ │ │ ├── swap.hpp
│ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ ├── type_traits/
│ │ │ │ │ │ ├── add_const.hpp
│ │ │ │ │ │ ├── add_lvalue_reference.hpp
│ │ │ │ │ │ ├── add_reference.hpp
│ │ │ │ │ │ ├── add_rvalue_reference.hpp
│ │ │ │ │ │ ├── add_volatile.hpp
│ │ │ │ │ │ ├── conditional.hpp
│ │ │ │ │ │ ├── declval.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ ├── is_function_ptr_helper.hpp
│ │ │ │ │ │ │ ├── is_function_ptr_tester.hpp
│ │ │ │ │ │ │ ├── is_mem_fun_pointer_impl.hpp
│ │ │ │ │ │ │ ├── is_mem_fun_pointer_tester.hpp
│ │ │ │ │ │ │ └── yes_no_type.hpp
│ │ │ │ │ │ ├── has_trivial_assign.hpp
│ │ │ │ │ │ ├── has_trivial_destructor.hpp
│ │ │ │ │ │ ├── integral_constant.hpp
│ │ │ │ │ │ ├── intrinsics.hpp
│ │ │ │ │ │ ├── is_abstract.hpp
│ │ │ │ │ │ ├── is_arithmetic.hpp
│ │ │ │ │ │ ├── is_array.hpp
│ │ │ │ │ │ ├── is_assignable.hpp
│ │ │ │ │ │ ├── is_base_and_derived.hpp
│ │ │ │ │ │ ├── is_class.hpp
│ │ │ │ │ │ ├── is_const.hpp
│ │ │ │ │ │ ├── is_convertible.hpp
│ │ │ │ │ │ ├── is_destructible.hpp
│ │ │ │ │ │ ├── is_enum.hpp
│ │ │ │ │ │ ├── is_floating_point.hpp
│ │ │ │ │ │ ├── is_function.hpp
│ │ │ │ │ │ ├── is_integral.hpp
│ │ │ │ │ │ ├── is_lvalue_reference.hpp
│ │ │ │ │ │ ├── is_member_function_pointer.hpp
│ │ │ │ │ │ ├── is_member_pointer.hpp
│ │ │ │ │ │ ├── is_pod.hpp
│ │ │ │ │ │ ├── is_pointer.hpp
│ │ │ │ │ │ ├── is_polymorphic.hpp
│ │ │ │ │ │ ├── is_reference.hpp
│ │ │ │ │ │ ├── is_rvalue_reference.hpp
│ │ │ │ │ │ ├── is_same.hpp
│ │ │ │ │ │ ├── is_scalar.hpp
│ │ │ │ │ │ ├── is_signed.hpp
│ │ │ │ │ │ ├── is_union.hpp
│ │ │ │ │ │ ├── is_unsigned.hpp
│ │ │ │ │ │ ├── is_void.hpp
│ │ │ │ │ │ ├── is_volatile.hpp
│ │ │ │ │ │ ├── make_signed.hpp
│ │ │ │ │ │ ├── remove_const.hpp
│ │ │ │ │ │ ├── remove_cv.hpp
│ │ │ │ │ │ └── remove_reference.hpp
│ │ │ │ │ ├── utility/
│ │ │ │ │ │ ├── declval.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── result_of_iterate.hpp
│ │ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ │ └── result_of.hpp
│ │ │ │ │ └── version.hpp
│ │ │ │ ├── boostqueue.h
│ │ │ │ ├── cpuid.cpp
│ │ │ │ ├── cpuid.h
│ │ │ │ ├── extract_graph_data.py
│ │ │ │ ├── lockbasedqueue.h
│ │ │ │ ├── simplelockfree.h
│ │ │ │ ├── stdqueue.h
│ │ │ │ ├── tbb/
│ │ │ │ │ ├── COPYING
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── aggregator.h
│ │ │ │ │ ├── aligned_space.h
│ │ │ │ │ ├── arena.cpp
│ │ │ │ │ ├── arena.h
│ │ │ │ │ ├── atomic.h
│ │ │ │ │ ├── blocked_range.h
│ │ │ │ │ ├── blocked_range2d.h
│ │ │ │ │ ├── blocked_range3d.h
│ │ │ │ │ ├── cache_aligned_allocator.cpp
│ │ │ │ │ ├── cache_aligned_allocator.h
│ │ │ │ │ ├── cilk-tbb-interop.h
│ │ │ │ │ ├── combinable.h
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── condition_variable
│ │ │ │ │ │ ├── ppl.h
│ │ │ │ │ │ ├── thread
│ │ │ │ │ │ └── tuple
│ │ │ │ │ ├── concurrent_hash_map.cpp
│ │ │ │ │ ├── concurrent_hash_map.h
│ │ │ │ │ ├── concurrent_lru_cache.h
│ │ │ │ │ ├── concurrent_monitor.cpp
│ │ │ │ │ ├── concurrent_monitor.h
│ │ │ │ │ ├── concurrent_priority_queue.h
│ │ │ │ │ ├── concurrent_queue.cpp
│ │ │ │ │ ├── concurrent_queue.h
│ │ │ │ │ ├── concurrent_unordered_map.h
│ │ │ │ │ ├── concurrent_unordered_set.h
│ │ │ │ │ ├── concurrent_vector.cpp
│ │ │ │ │ ├── concurrent_vector.h
│ │ │ │ │ ├── condition_variable.cpp
│ │ │ │ │ ├── critical_section.cpp
│ │ │ │ │ ├── critical_section.h
│ │ │ │ │ ├── custom_scheduler.h
│ │ │ │ │ ├── dynamic_link.cpp
│ │ │ │ │ ├── dynamic_link.h
│ │ │ │ │ ├── enumerable_thread_specific.h
│ │ │ │ │ ├── flow_graph.h
│ │ │ │ │ ├── governor.cpp
│ │ │ │ │ ├── governor.h
│ │ │ │ │ ├── ia32-masm/
│ │ │ │ │ │ ├── atomic_support.asm
│ │ │ │ │ │ ├── itsx.asm
│ │ │ │ │ │ └── lock_byte.asm
│ │ │ │ │ ├── ia64-gas/
│ │ │ │ │ │ ├── atomic_support.s
│ │ │ │ │ │ ├── ia64_misc.s
│ │ │ │ │ │ ├── lock_byte.s
│ │ │ │ │ │ ├── log2.s
│ │ │ │ │ │ └── pause.s
│ │ │ │ │ ├── ibm_aix51/
│ │ │ │ │ │ └── atomic_support.c
│ │ │ │ │ ├── intel64-masm/
│ │ │ │ │ │ ├── atomic_support.asm
│ │ │ │ │ │ ├── intel64_misc.asm
│ │ │ │ │ │ └── itsx.asm
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── _aggregator_impl.h
│ │ │ │ │ │ ├── _concurrent_queue_impl.h
│ │ │ │ │ │ ├── _concurrent_unordered_impl.h
│ │ │ │ │ │ ├── _flow_graph_impl.h
│ │ │ │ │ │ ├── _flow_graph_indexer_impl.h
│ │ │ │ │ │ ├── _flow_graph_item_buffer_impl.h
│ │ │ │ │ │ ├── _flow_graph_join_impl.h
│ │ │ │ │ │ ├── _flow_graph_node_impl.h
│ │ │ │ │ │ ├── _flow_graph_tagged_buffer_impl.h
│ │ │ │ │ │ ├── _flow_graph_trace_impl.h
│ │ │ │ │ │ ├── _flow_graph_types_impl.h
│ │ │ │ │ │ ├── _mutex_padding.h
│ │ │ │ │ │ ├── _range_iterator.h
│ │ │ │ │ │ ├── _tbb_strings.h
│ │ │ │ │ │ ├── _tbb_windef.h
│ │ │ │ │ │ ├── _x86_eliding_mutex_impl.h
│ │ │ │ │ │ └── _x86_rtm_rw_mutex_impl.h
│ │ │ │ │ ├── intrusive_list.h
│ │ │ │ │ ├── itt_notify.cpp
│ │ │ │ │ ├── itt_notify.h
│ │ │ │ │ ├── lin32-tbb-export.def
│ │ │ │ │ ├── lin32-tbb-export.lst
│ │ │ │ │ ├── lin64-tbb-export.def
│ │ │ │ │ ├── lin64-tbb-export.lst
│ │ │ │ │ ├── lin64ipf-tbb-export.def
│ │ │ │ │ ├── lin64ipf-tbb-export.lst
│ │ │ │ │ ├── mac32-tbb-export.def
│ │ │ │ │ ├── mac32-tbb-export.lst
│ │ │ │ │ ├── mac64-tbb-export.def
│ │ │ │ │ ├── mac64-tbb-export.lst
│ │ │ │ │ ├── machine/
│ │ │ │ │ │ ├── gcc_armv7.h
│ │ │ │ │ │ ├── gcc_generic.h
│ │ │ │ │ │ ├── gcc_ia32_common.h
│ │ │ │ │ │ ├── gcc_itsx.h
│ │ │ │ │ │ ├── ibm_aix51.h
│ │ │ │ │ │ ├── icc_generic.h
│ │ │ │ │ │ ├── linux_common.h
│ │ │ │ │ │ ├── linux_ia32.h
│ │ │ │ │ │ ├── linux_ia64.h
│ │ │ │ │ │ ├── linux_intel64.h
│ │ │ │ │ │ ├── mac_ppc.h
│ │ │ │ │ │ ├── macos_common.h
│ │ │ │ │ │ ├── mic_common.h
│ │ │ │ │ │ ├── msvc_armv7.h
│ │ │ │ │ │ ├── msvc_ia32_common.h
│ │ │ │ │ │ ├── sunos_sparc.h
│ │ │ │ │ │ ├── windows_api.h
│ │ │ │ │ │ ├── windows_ia32.h
│ │ │ │ │ │ ├── windows_intel64.h
│ │ │ │ │ │ └── xbox360_ppc.h
│ │ │ │ │ ├── mailbox.h
│ │ │ │ │ ├── market.cpp
│ │ │ │ │ ├── market.h
│ │ │ │ │ ├── memory_pool.h
│ │ │ │ │ ├── mutex.cpp
│ │ │ │ │ ├── mutex.h
│ │ │ │ │ ├── null_mutex.h
│ │ │ │ │ ├── null_rw_mutex.h
│ │ │ │ │ ├── observer_proxy.cpp
│ │ │ │ │ ├── observer_proxy.h
│ │ │ │ │ ├── parallel_do.h
│ │ │ │ │ ├── parallel_for.h
│ │ │ │ │ ├── parallel_for_each.h
│ │ │ │ │ ├── parallel_invoke.h
│ │ │ │ │ ├── parallel_reduce.h
│ │ │ │ │ ├── parallel_scan.h
│ │ │ │ │ ├── parallel_sort.h
│ │ │ │ │ ├── parallel_while.h
│ │ │ │ │ ├── partitioner.h
│ │ │ │ │ ├── pipeline.cpp
│ │ │ │ │ ├── pipeline.h
│ │ │ │ │ ├── private_server.cpp
│ │ │ │ │ ├── queuing_mutex.cpp
│ │ │ │ │ ├── queuing_mutex.h
│ │ │ │ │ ├── queuing_rw_mutex.cpp
│ │ │ │ │ ├── queuing_rw_mutex.h
│ │ │ │ │ ├── reader_writer_lock.cpp
│ │ │ │ │ ├── reader_writer_lock.h
│ │ │ │ │ ├── recursive_mutex.cpp
│ │ │ │ │ ├── recursive_mutex.h
│ │ │ │ │ ├── runtime_loader.h
│ │ │ │ │ ├── scalable_allocator.h
│ │ │ │ │ ├── scheduler.cpp
│ │ │ │ │ ├── scheduler.h
│ │ │ │ │ ├── scheduler_common.h
│ │ │ │ │ ├── scheduler_utility.h
│ │ │ │ │ ├── semaphore.cpp
│ │ │ │ │ ├── semaphore.h
│ │ │ │ │ ├── spin_mutex.cpp
│ │ │ │ │ ├── spin_mutex.h
│ │ │ │ │ ├── spin_rw_mutex.cpp
│ │ │ │ │ ├── spin_rw_mutex.h
│ │ │ │ │ ├── task.cpp
│ │ │ │ │ ├── task.h
│ │ │ │ │ ├── task_arena.h
│ │ │ │ │ ├── task_group.h
│ │ │ │ │ ├── task_group_context.cpp
│ │ │ │ │ ├── task_scheduler_init.h
│ │ │ │ │ ├── task_scheduler_observer.h
│ │ │ │ │ ├── task_stream.h
│ │ │ │ │ ├── tbb.h
│ │ │ │ │ ├── tbb_allocator.h
│ │ │ │ │ ├── tbb_assert_impl.h
│ │ │ │ │ ├── tbb_config.h
│ │ │ │ │ ├── tbb_exception.h
│ │ │ │ │ ├── tbb_machine.h
│ │ │ │ │ ├── tbb_main.cpp
│ │ │ │ │ ├── tbb_main.h
│ │ │ │ │ ├── tbb_misc.cpp
│ │ │ │ │ ├── tbb_misc.h
│ │ │ │ │ ├── tbb_misc_ex.cpp
│ │ │ │ │ ├── tbb_profiling.h
│ │ │ │ │ ├── tbb_resource.rc
│ │ │ │ │ ├── tbb_statistics.cpp
│ │ │ │ │ ├── tbb_statistics.h
│ │ │ │ │ ├── tbb_stddef.h
│ │ │ │ │ ├── tbb_thread.cpp
│ │ │ │ │ ├── tbb_thread.h
│ │ │ │ │ ├── tbb_version.h
│ │ │ │ │ ├── tbbmalloc_proxy.h
│ │ │ │ │ ├── tick_count.h
│ │ │ │ │ ├── tls.h
│ │ │ │ │ ├── tools_api/
│ │ │ │ │ │ ├── disable_warnings.h
│ │ │ │ │ │ ├── internal/
│ │ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ │ ├── ittnotify.h
│ │ │ │ │ │ ├── ittnotify_config.h
│ │ │ │ │ │ ├── ittnotify_static.c
│ │ │ │ │ │ ├── ittnotify_static.h
│ │ │ │ │ │ ├── ittnotify_types.h
│ │ │ │ │ │ ├── legacy/
│ │ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ │ └── prototype/
│ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ ├── version_string.ver
│ │ │ │ │ ├── win32-tbb-export.def
│ │ │ │ │ ├── win32-tbb-export.lst
│ │ │ │ │ ├── win64-gcc-tbb-export.def
│ │ │ │ │ ├── win64-gcc-tbb-export.lst
│ │ │ │ │ ├── win64-tbb-export.def
│ │ │ │ │ ├── win64-tbb-export.lst
│ │ │ │ │ ├── winrt-tbb-export.lst
│ │ │ │ │ ├── x86_rtm_rw_mutex.cpp
│ │ │ │ │ └── xbox360-tbb-export.def
│ │ │ │ ├── tbbqueue.h
│ │ │ │ └── wrappers.h
│ │ │ ├── blockingconcurrentqueue.h
│ │ │ ├── concurrentqueue.h
│ │ │ ├── internal/
│ │ │ │ └── concurrentqueue_internal_debug.h
│ │ │ ├── samples.md
│ │ │ └── tests/
│ │ │ ├── CDSChecker/
│ │ │ │ ├── README.txt
│ │ │ │ ├── corealgo.h
│ │ │ │ ├── enqueue_dequeue_many.cpp
│ │ │ │ └── enqueue_dequeue_one.cpp
│ │ │ ├── common/
│ │ │ │ ├── simplethread.cpp
│ │ │ │ ├── simplethread.h
│ │ │ │ ├── systemtime.cpp
│ │ │ │ └── systemtime.h
│ │ │ ├── corealgos.h
│ │ │ ├── fuzztests/
│ │ │ │ └── fuzztests.cpp
│ │ │ ├── relacy/
│ │ │ │ ├── freelist.cpp
│ │ │ │ ├── integrated.cpp
│ │ │ │ ├── relacy/
│ │ │ │ │ ├── CHANGES
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── VERSION
│ │ │ │ │ ├── example/
│ │ │ │ │ │ ├── cli_ws_deque/
│ │ │ │ │ │ │ ├── cli_ws_deque.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── cli_ws_deque.sln
│ │ │ │ │ │ │ │ └── cli_ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── condvar/
│ │ │ │ │ │ │ ├── condvar.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── condvar.sln
│ │ │ │ │ │ │ │ └── condvar.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── condvar.sln
│ │ │ │ │ │ │ │ └── condvar.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── eao_blocking/
│ │ │ │ │ │ │ └── eao_blocking.cpp
│ │ │ │ │ │ ├── eventcount/
│ │ │ │ │ │ │ ├── eventcount.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── examples/
│ │ │ │ │ │ │ ├── amp_condvar.hpp
│ │ │ │ │ │ │ ├── examples.cpp
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── examples.sln
│ │ │ │ │ │ │ │ └── examples.vcproj
│ │ │ │ │ │ │ ├── spsc_overwrite_queue.hpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── java_ws_deque/
│ │ │ │ │ │ │ ├── java_ws_deque.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── java_ws_deque.sln
│ │ │ │ │ │ │ │ └── java_ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── mpmc/
│ │ │ │ │ │ │ ├── mpmc.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── mpmc.sln
│ │ │ │ │ │ │ │ └── mpmc.vcproj
│ │ │ │ │ │ │ ├── pcx.h
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── mutex_business_logic/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── mutex_business_logic.sln
│ │ │ │ │ │ │ │ └── mutex_business_logic.vcproj
│ │ │ │ │ │ │ ├── mutex_business_logic.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── peterson/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── peterson.sln
│ │ │ │ │ │ │ │ └── peterson.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── peterson.sln
│ │ │ │ │ │ │ │ └── peterson.vcproj
│ │ │ │ │ │ │ ├── peterson.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── proxy_collector/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ │ │ │ ├── proxy_collector.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── ref_counting/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ │ │ │ ├── ref_counting.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── smr/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── smr.sln
│ │ │ │ │ │ │ │ └── smr.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── smr.sln
│ │ │ │ │ │ │ │ └── smr.vcproj
│ │ │ │ │ │ │ ├── smr.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── spsc_queue/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ │ │ │ ├── spsc_queue.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── stack/
│ │ │ │ │ │ │ ├── DESCRIPTION.TXT
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── stack.sln
│ │ │ │ │ │ │ │ └── stack.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── stack.sln
│ │ │ │ │ │ │ │ └── stack.vcproj
│ │ │ │ │ │ │ ├── stack.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── tbb_eventcount/
│ │ │ │ │ │ │ ├── eventcount.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── ws_deque/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ ├── stdafx.h
│ │ │ │ │ │ │ └── ws_deque.cpp
│ │ │ │ │ │ └── ws_deque2/
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ ├── stdafx.h
│ │ │ │ │ │ └── ws_deque.cpp
│ │ │ │ │ ├── relacy/
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── atomic_events.hpp
│ │ │ │ │ │ ├── atomic_fence.hpp
│ │ │ │ │ │ ├── backoff.hpp
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ ├── cli.hpp
│ │ │ │ │ │ ├── cli_interlocked.hpp
│ │ │ │ │ │ ├── cli_var.hpp
│ │ │ │ │ │ ├── cli_volatile.hpp
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── context_addr_hash.hpp
│ │ │ │ │ │ ├── context_base.hpp
│ │ │ │ │ │ ├── context_base_impl.hpp
│ │ │ │ │ │ ├── context_bound_scheduler.hpp
│ │ │ │ │ │ ├── defs.hpp
│ │ │ │ │ │ ├── dyn_thread.hpp
│ │ │ │ │ │ ├── dyn_thread_ctx.hpp
│ │ │ │ │ │ ├── foreach.hpp
│ │ │ │ │ │ ├── full_search_scheduler.hpp
│ │ │ │ │ │ ├── history.hpp
│ │ │ │ │ │ ├── java.hpp
│ │ │ │ │ │ ├── java_atomic.hpp
│ │ │ │ │ │ ├── java_var.hpp
│ │ │ │ │ │ ├── java_volatile.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ │ ├── pch.hpp
│ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ ├── pthread.h
│ │ │ │ │ │ ├── random.hpp
│ │ │ │ │ │ ├── random_scheduler.hpp
│ │ │ │ │ │ ├── relacy.hpp
│ │ │ │ │ │ ├── relacy_cli.hpp
│ │ │ │ │ │ ├── relacy_java.hpp
│ │ │ │ │ │ ├── relacy_std.hpp
│ │ │ │ │ │ ├── rmw.hpp
│ │ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ │ ├── signature.hpp
│ │ │ │ │ │ ├── slab_allocator.hpp
│ │ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ │ ├── pthread.hpp
│ │ │ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ │ │ └── windows.hpp
│ │ │ │ │ │ ├── sync_var.hpp
│ │ │ │ │ │ ├── test_params.hpp
│ │ │ │ │ │ ├── test_result.hpp
│ │ │ │ │ │ ├── test_suite.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_base.hpp
│ │ │ │ │ │ ├── thread_local.hpp
│ │ │ │ │ │ ├── thread_local_ctx.hpp
│ │ │ │ │ │ ├── var.hpp
│ │ │ │ │ │ ├── volatile.hpp
│ │ │ │ │ │ ├── waitset.hpp
│ │ │ │ │ │ └── windows.h
│ │ │ │ │ └── test/
│ │ │ │ │ ├── addr_hash.hpp
│ │ │ │ │ ├── advanced.txt
│ │ │ │ │ ├── compare_swap.hpp
│ │ │ │ │ ├── condvar.hpp
│ │ │ │ │ ├── data_race.hpp
│ │ │ │ │ ├── detection.txt
│ │ │ │ │ ├── dyn_thread.hpp
│ │ │ │ │ ├── event.hpp
│ │ │ │ │ ├── features.txt
│ │ │ │ │ ├── fence.hpp
│ │ │ │ │ ├── foo.cpp
│ │ │ │ │ ├── futex.hpp
│ │ │ │ │ ├── g++/
│ │ │ │ │ │ ├── build_all_cygwin_debug.bat
│ │ │ │ │ │ ├── build_all_debug.bat
│ │ │ │ │ │ ├── build_all_release.sh
│ │ │ │ │ │ ├── build_cygwin_release.cmd
│ │ │ │ │ │ ├── build_debug.cmd
│ │ │ │ │ │ ├── build_release.cmd
│ │ │ │ │ │ └── test.cpp
│ │ │ │ │ ├── jtest/
│ │ │ │ │ │ ├── jtest.cpp
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── jtest.sln
│ │ │ │ │ │ │ └── jtest.vcproj
│ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ ├── jtest.sln
│ │ │ │ │ │ │ └── jtest.vcproj
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ ├── main.cpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ ├── msvc71/
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ ├── rrd.sln
│ │ │ │ │ │ ├── rrd.vcproj
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ ├── rrd.sln
│ │ │ │ │ │ ├── rrd.vcproj
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ ├── ntest/
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── ntest.sln
│ │ │ │ │ │ │ └── ntest.vcproj
│ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ ├── ntest.sln
│ │ │ │ │ │ │ └── ntest.vcproj
│ │ │ │ │ │ ├── ntest.cpp
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ ├── pthread.hpp
│ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ ├── stdafx.h
│ │ │ │ │ ├── thread_local.hpp
│ │ │ │ │ ├── todo.txt
│ │ │ │ │ ├── trash/
│ │ │ │ │ │ ├── original.hpp
│ │ │ │ │ │ └── rtl.hpp
│ │ │ │ │ ├── tutorial.txt
│ │ │ │ │ ├── wfmo.hpp
│ │ │ │ │ └── windows.hpp
│ │ │ │ ├── relacy_shims.h
│ │ │ │ └── spmchash.cpp
│ │ │ └── unittests/
│ │ │ ├── mallocmacro.cpp
│ │ │ ├── minitest.h
│ │ │ └── unittests.cpp
│ │ ├── fmt/
│ │ │ ├── .clang-format
│ │ │ ├── .github/
│ │ │ │ └── pull_request_template.md
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── ChangeLog.rst
│ │ │ ├── LICENSE.rst
│ │ │ ├── README.rst
│ │ │ ├── include/
│ │ │ │ └── fmt/
│ │ │ │ ├── chrono.h
│ │ │ │ ├── color.h
│ │ │ │ ├── core.h
│ │ │ │ ├── format-inl.h
│ │ │ │ ├── format.h
│ │ │ │ ├── locale.h
│ │ │ │ ├── ostream.h
│ │ │ │ ├── posix.h
│ │ │ │ ├── prepare.h
│ │ │ │ ├── printf.h
│ │ │ │ ├── ranges.h
│ │ │ │ └── safe-duration-cast.h
│ │ │ ├── src/
│ │ │ │ ├── format.cc
│ │ │ │ └── posix.cc
│ │ │ └── support/
│ │ │ └── cmake/
│ │ │ ├── FindSetEnv.cmake
│ │ │ ├── cxx14.cmake
│ │ │ ├── fmt-config.cmake.in
│ │ │ └── fmt.pc.in
│ │ ├── pybind11/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .readthedocs.yml
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── ISSUE_TEMPLATE.md
│ │ │ ├── LICENSE
│ │ │ ├── MANIFEST.in
│ │ │ ├── README.md
│ │ │ ├── docs/
│ │ │ │ ├── Doxyfile
│ │ │ │ ├── _static/
│ │ │ │ │ └── theme_overrides.css
│ │ │ │ ├── advanced/
│ │ │ │ │ ├── cast/
│ │ │ │ │ │ ├── chrono.rst
│ │ │ │ │ │ ├── custom.rst
│ │ │ │ │ │ ├── eigen.rst
│ │ │ │ │ │ ├── functional.rst
│ │ │ │ │ │ ├── index.rst
│ │ │ │ │ │ ├── overview.rst
│ │ │ │ │ │ ├── stl.rst
│ │ │ │ │ │ └── strings.rst
│ │ │ │ │ ├── classes.rst
│ │ │ │ │ ├── embedding.rst
│ │ │ │ │ ├── exceptions.rst
│ │ │ │ │ ├── functions.rst
│ │ │ │ │ ├── misc.rst
│ │ │ │ │ ├── pycpp/
│ │ │ │ │ │ ├── index.rst
│ │ │ │ │ │ ├── numpy.rst
│ │ │ │ │ │ ├── object.rst
│ │ │ │ │ │ └── utilities.rst
│ │ │ │ │ └── smart_ptrs.rst
│ │ │ │ ├── basics.rst
│ │ │ │ ├── benchmark.py
│ │ │ │ ├── benchmark.rst
│ │ │ │ ├── changelog.rst
│ │ │ │ ├── classes.rst
│ │ │ │ ├── compiling.rst
│ │ │ │ ├── conf.py
│ │ │ │ ├── faq.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── intro.rst
│ │ │ │ ├── limitations.rst
│ │ │ │ ├── reference.rst
│ │ │ │ ├── release.rst
│ │ │ │ ├── requirements.txt
│ │ │ │ └── upgrade.rst
│ │ │ ├── include/
│ │ │ │ └── pybind11/
│ │ │ │ ├── attr.h
│ │ │ │ ├── buffer_info.h
│ │ │ │ ├── cast.h
│ │ │ │ ├── chrono.h
│ │ │ │ ├── common.h
│ │ │ │ ├── complex.h
│ │ │ │ ├── detail/
│ │ │ │ │ ├── class.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── descr.h
│ │ │ │ │ ├── init.h
│ │ │ │ │ ├── internals.h
│ │ │ │ │ └── typeid.h
│ │ │ │ ├── eigen.h
│ │ │ │ ├── embed.h
│ │ │ │ ├── eval.h
│ │ │ │ ├── functional.h
│ │ │ │ ├── iostream.h
│ │ │ │ ├── numpy.h
│ │ │ │ ├── operators.h
│ │ │ │ ├── options.h
│ │ │ │ ├── pybind11.h
│ │ │ │ ├── pytypes.h
│ │ │ │ ├── stl.h
│ │ │ │ └── stl_bind.h
│ │ │ ├── pybind11/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── __main__.py
│ │ │ │ └── _version.py
│ │ │ ├── setup.cfg
│ │ │ ├── setup.py
│ │ │ ├── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── conftest.py
│ │ │ │ ├── constructor_stats.h
│ │ │ │ ├── local_bindings.h
│ │ │ │ ├── object.h
│ │ │ │ ├── pybind11_cross_module_tests.cpp
│ │ │ │ ├── pybind11_tests.cpp
│ │ │ │ ├── pybind11_tests.h
│ │ │ │ ├── pytest.ini
│ │ │ │ ├── test_buffers.cpp
│ │ │ │ ├── test_buffers.py
│ │ │ │ ├── test_builtin_casters.cpp
│ │ │ │ ├── test_builtin_casters.py
│ │ │ │ ├── test_call_policies.cpp
│ │ │ │ ├── test_call_policies.py
│ │ │ │ ├── test_callbacks.cpp
│ │ │ │ ├── test_callbacks.py
│ │ │ │ ├── test_chrono.cpp
│ │ │ │ ├── test_chrono.py
│ │ │ │ ├── test_class.cpp
│ │ │ │ ├── test_class.py
│ │ │ │ ├── test_cmake_build/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── embed.cpp
│ │ │ │ │ ├── installed_embed/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── installed_function/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── installed_target/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── main.cpp
│ │ │ │ │ ├── subdirectory_embed/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── subdirectory_function/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── subdirectory_target/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ └── test.py
│ │ │ │ ├── test_constants_and_functions.cpp
│ │ │ │ ├── test_constants_and_functions.py
│ │ │ │ ├── test_copy_move.cpp
│ │ │ │ ├── test_copy_move.py
│ │ │ │ ├── test_docstring_options.cpp
│ │ │ │ ├── test_docstring_options.py
│ │ │ │ ├── test_eigen.cpp
│ │ │ │ ├── test_eigen.py
│ │ │ │ ├── test_embed/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── catch.cpp
│ │ │ │ │ ├── external_module.cpp
│ │ │ │ │ ├── test_interpreter.cpp
│ │ │ │ │ └── test_interpreter.py
│ │ │ │ ├── test_enum.cpp
│ │ │ │ ├── test_enum.py
│ │ │ │ ├── test_eval.cpp
│ │ │ │ ├── test_eval.py
│ │ │ │ ├── test_eval_call.py
│ │ │ │ ├── test_exceptions.cpp
│ │ │ │ ├── test_exceptions.py
│ │ │ │ ├── test_factory_constructors.cpp
│ │ │ │ ├── test_factory_constructors.py
│ │ │ │ ├── test_gil_scoped.cpp
│ │ │ │ ├── test_gil_scoped.py
│ │ │ │ ├── test_iostream.cpp
│ │ │ │ ├── test_iostream.py
│ │ │ │ ├── test_kwargs_and_defaults.cpp
│ │ │ │ ├── test_kwargs_and_defaults.py
│ │ │ │ ├── test_local_bindings.cpp
│ │ │ │ ├── test_local_bindings.py
│ │ │ │ ├── test_methods_and_attributes.cpp
│ │ │ │ ├── test_methods_and_attributes.py
│ │ │ │ ├── test_modules.cpp
│ │ │ │ ├── test_modules.py
│ │ │ │ ├── test_multiple_inheritance.cpp
│ │ │ │ ├── test_multiple_inheritance.py
│ │ │ │ ├── test_numpy_array.cpp
│ │ │ │ ├── test_numpy_array.py
│ │ │ │ ├── test_numpy_dtypes.cpp
│ │ │ │ ├── test_numpy_dtypes.py
│ │ │ │ ├── test_numpy_vectorize.cpp
│ │ │ │ ├── test_numpy_vectorize.py
│ │ │ │ ├── test_opaque_types.cpp
│ │ │ │ ├── test_opaque_types.py
│ │ │ │ ├── test_operator_overloading.cpp
│ │ │ │ ├── test_operator_overloading.py
│ │ │ │ ├── test_pickling.cpp
│ │ │ │ ├── test_pickling.py
│ │ │ │ ├── test_pytypes.cpp
│ │ │ │ ├── test_pytypes.py
│ │ │ │ ├── test_sequences_and_iterators.cpp
│ │ │ │ ├── test_sequences_and_iterators.py
│ │ │ │ ├── test_smart_ptr.cpp
│ │ │ │ ├── test_smart_ptr.py
│ │ │ │ ├── test_stl.cpp
│ │ │ │ ├── test_stl.py
│ │ │ │ ├── test_stl_binders.cpp
│ │ │ │ ├── test_stl_binders.py
│ │ │ │ ├── test_tagbased_polymorphic.cpp
│ │ │ │ ├── test_tagbased_polymorphic.py
│ │ │ │ ├── test_virtual_functions.cpp
│ │ │ │ └── test_virtual_functions.py
│ │ │ └── tools/
│ │ │ ├── FindCatch.cmake
│ │ │ ├── FindEigen3.cmake
│ │ │ ├── FindPythonLibsNew.cmake
│ │ │ ├── check-style.sh
│ │ │ ├── libsize.py
│ │ │ ├── mkdoc.py
│ │ │ ├── pybind11Config.cmake.in
│ │ │ └── pybind11Tools.cmake
│ │ └── zstd/
│ │ └── lib/
│ │ ├── README.md
│ │ ├── common/
│ │ │ ├── bitstream.h
│ │ │ ├── compiler.h
│ │ │ ├── cpu.h
│ │ │ ├── debug.c
│ │ │ ├── debug.h
│ │ │ ├── entropy_common.c
│ │ │ ├── error_private.c
│ │ │ ├── error_private.h
│ │ │ ├── fse.h
│ │ │ ├── fse_decompress.c
│ │ │ ├── huf.h
│ │ │ ├── mem.h
│ │ │ ├── pool.c
│ │ │ ├── pool.h
│ │ │ ├── threading.c
│ │ │ ├── threading.h
│ │ │ ├── xxhash.c
│ │ │ ├── xxhash.h
│ │ │ ├── zstd_common.c
│ │ │ ├── zstd_errors.h
│ │ │ └── zstd_internal.h
│ │ ├── compress/
│ │ │ ├── fse_compress.c
│ │ │ ├── hist.c
│ │ │ ├── hist.h
│ │ │ ├── huf_compress.c
│ │ │ ├── zstd_compress.c
│ │ │ ├── zstd_compress_internal.h
│ │ │ ├── zstd_compress_literals.c
│ │ │ ├── zstd_compress_literals.h
│ │ │ ├── zstd_compress_sequences.c
│ │ │ ├── zstd_compress_sequences.h
│ │ │ ├── zstd_compress_superblock.c
│ │ │ ├── zstd_compress_superblock.h
│ │ │ ├── zstd_cwksp.h
│ │ │ ├── zstd_double_fast.c
│ │ │ ├── zstd_double_fast.h
│ │ │ ├── zstd_fast.c
│ │ │ ├── zstd_fast.h
│ │ │ ├── zstd_lazy.c
│ │ │ ├── zstd_lazy.h
│ │ │ ├── zstd_ldm.c
│ │ │ ├── zstd_ldm.h
│ │ │ ├── zstd_opt.c
│ │ │ ├── zstd_opt.h
│ │ │ ├── zstdmt_compress.c
│ │ │ └── zstdmt_compress.h
│ │ ├── decompress/
│ │ │ ├── huf_decompress.c
│ │ │ ├── zstd_ddict.c
│ │ │ ├── zstd_ddict.h
│ │ │ ├── zstd_decompress.c
│ │ │ ├── zstd_decompress_block.c
│ │ │ ├── zstd_decompress_block.h
│ │ │ └── zstd_decompress_internal.h
│ │ ├── deprecated/
│ │ │ ├── zbuff.h
│ │ │ ├── zbuff_common.c
│ │ │ ├── zbuff_compress.c
│ │ │ └── zbuff_decompress.c
│ │ ├── dictBuilder/
│ │ │ ├── cover.c
│ │ │ ├── cover.h
│ │ │ ├── divsufsort.c
│ │ │ ├── divsufsort.h
│ │ │ ├── fastcover.c
│ │ │ ├── zdict.c
│ │ │ └── zdict.h
│ │ ├── dll/
│ │ │ └── example/
│ │ │ ├── README.md
│ │ │ ├── build_package.bat
│ │ │ ├── fullbench-dll.sln
│ │ │ └── fullbench-dll.vcxproj
│ │ ├── legacy/
│ │ │ ├── zstd_legacy.h
│ │ │ ├── zstd_v01.c
│ │ │ ├── zstd_v01.h
│ │ │ ├── zstd_v02.c
│ │ │ ├── zstd_v02.h
│ │ │ ├── zstd_v03.c
│ │ │ ├── zstd_v03.h
│ │ │ ├── zstd_v04.c
│ │ │ ├── zstd_v04.h
│ │ │ ├── zstd_v05.c
│ │ │ ├── zstd_v05.h
│ │ │ ├── zstd_v06.c
│ │ │ ├── zstd_v06.h
│ │ │ ├── zstd_v07.c
│ │ │ └── zstd_v07.h
│ │ ├── libzstd.pc.in
│ │ └── zstd.h
│ └── tube/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── pytube/
│ │ ├── __init__.py
│ │ ├── data_channel_manager.py
│ │ ├── test_dc_manager.py
│ │ └── utils.py
│ └── src_cpp/
│ ├── context.h
│ ├── data_block.h
│ ├── data_channel.cc
│ ├── data_channel.h
│ ├── dispatcher.h
│ ├── env_thread.h
│ ├── episodic_trajectory.h
│ ├── fixed_len_trajectory.h
│ ├── indefinite_trajectory.h
│ ├── pybind.cc
│ ├── test/
│ │ ├── test_data_channel.cc
│ │ └── test_producer.h
│ └── utils.h
└── tests/
├── CMakeLists.txt
├── README.md
├── connectfour-tests.cc
├── havannah-state-tests.cc
├── havannah-tests.cc
├── hex-state-tests.cc
├── hex-tests.cc
├── ludii-game-tests.cc
├── python/
│ └── test_replay_buffer.py
├── tests.cc
└── utils.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .circleci/config.yml
================================================
# Python CircleCI 2.0 configuration file
#
# Check https://circleci.com/docs/2.0/language-python/ for more details
#
version: 2
jobs:
build:
branches:
ignore:
- dennis-tests
docker:
# specify the version you desire here
# use `-browsers` prefix for selenium tests, e.g. `3.6.1-browsers`
#- image: circleci/python:3.6.1
#- image: singularityware/singularity:3.1-slim # would be faster but interacts badly with cuda docker image loading
- image : nvidia/cuda:10.0-cudnn7-devel-ubuntu18.04
# machine: true
working_directory: ~/repo
# resource_class: xlarge # not activated for the project
steps:
- checkout
#- run:
#- name: Install singularity
#- command: |
#- #chmod u+x ~/repo/.circleci/*.sh
#- #/bin/bash ~/repo/.circleci/install_singularity.sh
#- sudo wget -O- http://neuro.debian.net/lists/xenial.us-ca.full | sudo tee /etc/apt/sources.list.d/neurodebian.sources.list && \
#- sudo apt-key adv --recv-keys --keyserver hkp://pool.sks-keyservers.net:80 0xA5D32F012649A5A9 && \
#- sudo apt-get update
#- sudo apt-get install -y singularity-container
- restore_cache:
keys:
- tag3-conda-{{ checksum "singularity/environment.yml" }}-pytorch
- tag3-conda-{{ checksum "singularity/environment.yml" }}
- tag1-conda
- run:
name: Install miniconda and clone pytorch
command: |
apt-get update
apt-get install -y \
build-essential \
libzmq3-dev \
cmake \
wget \
vim \
git \
ca-certificates \
libjpeg-dev \
openjdk-8-jdk \
libgtest-dev \
libpng-dev
rm -rf /var/lib/apt/lists/
# build gtest (for polygames-tests)
cd /usr/src/googletest/googletest
mkdir build
cd build
cmake ..
make
cp libgtest* /usr/lib/
cd ..
rm -rf build
# conda
CHECKPATH=/opt/conda
if [ -d "$CHECKPATH" ]; then
echo "$CHECKPATH already exists"
else
wget -O ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ~/miniconda.sh -b -p /opt/conda
rm ~/miniconda.sh
git clone --recursive https://github.com/pytorch/pytorch --branch=v1.1.0 ~/pytorch
fi
- save_cache:
paths:
- /opt/conda
- ~/pytorch
key: tag1-conda
- run:
name: Install conda environment
command: |
CHECKPATH=/opt/conda/envs/pypg
. /opt/conda/etc/profile.d/conda.sh
if [ -d "$CHECKPATH" ]; then
echo "$CHECKPATH already exists"
# conda env update -f singularity/environment.yml --name pypg
else
conda env create -f singularity/environment.yml --name pypg
conda activate pypg
pip install mypy>=0.630 pytest>=4.3.0 pytest-cov>=2.6.1 # only required for testing
fi
- save_cache:
paths:
- /opt/conda
- ~/pytorch
key: tag3-conda-{{ checksum "singularity/environment.yml" }}
- run:
name: Install pytorch
command: |
CHECKPATH=~/pytorch/done
if [ -f "$CHECKPATH" ]; then
echo "pytorch already exists"
else
. /opt/conda/etc/profile.d/conda.sh
conda activate pypg
which pip
pip install -U pip
cd ~/pytorch
export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
# export MAX_JOBS=$(cat /proc/cpuinfo | grep -c processor)
# if (( $MAX_JOBS < 4 ));
# then MAX_JOBS=4;
# fi;
export MAX_JOBS=4 # calibrate for circleci resources...
echo "Using $MAX_JOBS jobs for pytorch compilation"
# # set cuda arch list so that the built binary can be run on both pascal and volta
MAX_JOBS=$MAX_JOBS TORCH_CUDA_ARCH_LIST='6.0;7.0' pip install . -v
touch $CHECKPATH
fi
- save_cache:
paths:
- /opt/conda
- ~/pytorch
key: tag3-conda-{{ checksum "singularity/environment.yml" }}-pytorch
- run:
name: Build polygames
command: |
. /opt/conda/etc/profile.d/conda.sh
conda activate pypg
mkdir build
cd build
cmake ..
make -j 2
- run:
name: Build polygames-tests
command: |
. /opt/conda/etc/profile.d/conda.sh
conda activate pypg
mkdir ludii
wget -P ludii https://ludii.games/downloads/Ludii.jar
mkdir tests/build
cd tests/build
cmake ..
make -j 2
- run:
name: Test games
command: |
./build/test_state
- run:
name: Test polygames-tests (unit tests)
command: |
./tests/build/polygames-tests
- run:
name: Test Mcts
command: |
./build/torchRL/mcts/test_mcts 1 100
./build/torchRL/mcts/test_mcts 4 50
- run:
name: Test python
command: |
. /opt/conda/etc/profile.d/conda.sh
conda activate pypg
pytest pypolygames --durations=10 --verbose
- run:
name: Run training
command: |
. /opt/conda/etc/profile.d/conda.sh
conda activate pypg
python -m pypolygames traineval --act_batchsize=2 \
--batchsize=2 --replay_capacity=16 --replay_warmup=2 \
--num_epoch=1 --num_game=12 --model_name=NanoFCLogitModel \
--epoch_len=1 --device=cpu --game_name=TicTacToe --sync_period=1 --device_eval=cpu \
--num_actor_eval=2 --num_rollouts_opponent=50 --num_game_eval=4
================================================
FILE: .clang-format
================================================
AccessModifierOffset: -1
AllowShortFunctionsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
BinPackParameters: false
BreakConstructorInitializersBeforeComma: true
PenaltyBreakBeforeFirstCallParameter: 0
PenaltyReturnTypeOnItsOwnLine: 200
PointerBindsToType: true
SpacesBeforeTrailingComments: 2
================================================
FILE: .github/CONTRIBUTING.md
================================================
# Contributing to Polygames
We want to make contributing to this project as easy and transparent as
possible.
## Pull Requests
We actively welcome your pull requests.
1. Fork the repo and create your branch from `master`.
2. If you've added code that should be tested, add tests.
3. If you've changed APIs, update the documentation.
4. Ensure the test suite passes.
5. Make sure your code lints.
6. If you haven't already, complete the Contributor License Agreement ("CLA").
## Our Development Process
Any pull request will trigger continuous integration. Its configuration is
available [here](../.circleci/config.yml).
In particular it defines tests that you should try to run locally as well:
- testing mcts and state C++ code
```
./build/test_state
./build/torchRL/mcts/test_mcts 1 100
./build/torchRL/mcts/test_mcts 4 50
```
- testing the python tools:
```
pytest pypolygames --durations=10 --verbose
```
- trying a short training:
```
python -m pypolygames traineval --act_batchsize=2 \
--batchsize=2 --replay_capacity=16 --replay_warmup=2 \
--num_epoch=1 --num_game=12 --model_name=NanoFCLogitModel \
--epoch_len=1 --device=cpu --game_name=TicTacToe --sync_period=1 --device_eval=cpu \
--num_actor_eval=2 --num_rollouts_opponent=50 --num_game_eval=4
```
## Contributor License Agreement ("CLA")
In order to accept your pull request, we need you to submit a CLA. You only need
to do this once to work on any of Facebook's open source projects.
Complete your CLA here: <https://code.facebook.com/cla>
## Issues
We use GitHub issues to track public bugs. Please ensure your description is
clear and has sufficient instructions to be able to reproduce the issue.
## Coding Style
The root contains a ```.clang-format``` file that define the coding style of
this repo, run the following command before submitting PR or push
```
clang-format -i path_to_your_cc_files
clang-format -i path_to_your_h_files
```
## License
By contributing to `Polygames`, you agree that your contributions will be licensed
under the LICENSE file in the root directory of this source tree.
================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
## Steps to reproduce
1. _____
2. _____
3. _____
## Observed Results
* What happened? This could be a description, log output, etc.
## Expected Results
* What did you expect to happen?
## Relevant Code
```
// TODO(you): code here to reproduce the problem
```
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
## Types of changes
<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
- [ ] Docs change / refactoring / dependency upgrade
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)
## Motivation and Context / Related issue
<!--- Why is this change required? What problem does it solve? -->
<!--- Please link to an existing issue here if one exists. -->
<!--- (we recommend to have an existing issue for each pull request) -->
## How Has This Been Tested (if it applies)
<!--- Please describe here how your modifications have been tested. -->
## Checklist
<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
- [ ] The documentation is up-to-date with the changes I made.
- [ ] I have read the **CONTRIBUTING** document and completed the CLA (see **CONTRIBUTING**).
- [ ] All tests passed, and additional code has been covered with new tests.
================================================
FILE: .gitignore
================================================
# Created by https://www.gitignore.io/api/vim,c++,cmake,linux,macos,python,intellij,sublimetext
# Edit at https://www.gitignore.io/?templates=vim,c++,cmake,linux,macos,python,intellij,sublimetext
### C++ ###
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
### CMake ###
CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
CMakeScripts
Testing
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
_deps
### CMake Patch ###
# External projects
*-prefix/
### Intellij ###
# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
# User-specific stuff
.idea/**/workspace.xml
.idea/**/tasks.xml
.idea/**/usage.statistics.xml
.idea/**/dictionaries
.idea/**/shelf
# Generated files
.idea/**/contentModel.xml
# Sensitive or high-churn files
.idea/**/dataSources/
.idea/**/dataSources.ids
.idea/**/dataSources.local.xml
.idea/**/sqlDataSources.xml
.idea/**/dynamic.xml
.idea/**/uiDesigner.xml
.idea/**/dbnavigator.xml
# Gradle
.idea/**/gradle.xml
.idea/**/libraries
# Gradle and Maven with auto-import
# When using Gradle or Maven with auto-import, you should exclude module files,
# since they will be recreated, and may cause churn. Uncomment if using
# auto-import.
# .idea/modules.xml
# .idea/*.iml
# .idea/modules
# CMake
cmake-build-*/
# Mongo Explorer plugin
.idea/**/mongoSettings.xml
# File-based project format
*.iws
# IntelliJ
out/
# mpeltonen/sbt-idea plugin
.idea_modules/
# JIRA plugin
atlassian-ide-plugin.xml
# Cursive Clojure plugin
.idea/replstate.xml
# Crashlytics plugin (for Android Studio and IntelliJ)
com_crashlytics_export_strings.xml
crashlytics.properties
crashlytics-build.properties
fabric.properties
# Editor-based Rest Client
.idea/httpRequests
# Android studio 3.1+ serialized cache file
.idea/caches/build_file_checksums.ser
# JetBrains templates
**___jb_tmp___
### Intellij Patch ###
# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
# *.iml
# modules.xml
# .idea/misc.xml
# *.ipr
# Sonarlint plugin
.idea/sonarlint
### Linux ###
*~
# temporary files which can be created if a process still has a handle open of a deleted file
.fuse_hidden*
# KDE directory preferences
.directory
# Linux trash folder which might appear on any partition or disk
.Trash-*
# .nfs files are created when an open file is removed but is still being accessed
.nfs*
### macOS ###
# General
.DS_Store
.AppleDouble
.LSOverride
# Icon must end with two \r
Icon
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
.python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don’t work, or not
# install all needed dependencies.
#Pipfile.lock
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
### SublimeText ###
# Cache files for Sublime Text
*.tmlanguage.cache
*.tmPreferences.cache
*.stTheme.cache
# Workspace files are user-specific
*.sublime-workspace
# Project files should be checked into the repository, unless a significant
# proportion of contributors will probably not be using Sublime Text
# *.sublime-project
# SFTP configuration file
sftp-config.json
# Package control specific files
Package Control.last-run
Package Control.ca-list
Package Control.ca-bundle
Package Control.system-ca-bundle
Package Control.cache/
Package Control.ca-certs/
Package Control.merged-ca-bundle
Package Control.user-ca-bundle
oscrypto-ca-bundle.crt
bh_unicode_properties.cache
# Sublime-github package stores a github token in this file
# https://packagecontrol.io/packages/sublime-github
GitHub.sublime-settings
### Vim ###
# Swap
[._]*.s[a-v][a-z]
[._]*.sw[a-p]
[._]s[a-rt-v][a-z]
[._]ss[a-gi-z]
[._]sw[a-p]
# Session
Session.vim
# Temporary
.netrwhist
# Auto-generated tag files
tags
# Persistent undo
[._]*.un~
# End of https://www.gitignore.io/api/vim,c++,cmake,linux,macos,python,intellij,sublimetext
*.simg
cmake-build-debug/
# Visual Studio Code
.vscode/
# Eclipse projects
/.cproject
/.project
.settings/
# Experiment directory
exps/
# For some people testing
run.sh
# Ludii's JAR file
ludii/Ludii.jar
================================================
FILE: CMakeLists.txt
================================================
CMAKE_MINIMUM_REQUIRED(VERSION 3.3)
project(polygames)
# if(NOT CMAKE_BUILD_TYPE)
# set(CMAKE_BUILD_TYPE RelWithDebInfo)
# endif()
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_FLAGS
"${CMAKE_CXX_FLAGS} -fsized-deallocation -O3 -ffast-math")
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
OPTION(PYTORCH12 "Is PyTorch >= 1.2" OFF)
OPTION(PYTORCH15 "Is PyTorch >= 1.5" OFF)
IF(PYTORCH15)
ADD_DEFINITIONS(-DPYTORCH15 -DPYTORCH12)
ELSEIF(PYTORCH12)
ADD_DEFINITIONS(-DPYTORCH12)
ENDIF()
execute_process(
COMMAND python -c "import torch; import os; print(os.path.dirname(torch.__file__), end='')"
OUTPUT_VARIABLE TorchPath
)
set(CMAKE_PREFIX_PATH ${TorchPath})
find_package(Torch REQUIRED)
find_package(Boost COMPONENTS system)
if( Boost_FOUND )
include_directories( ${Boost_INCLUDE_DIRS})
endif()
option(WITH_LUDII "Include LUDII support" ON)
if(WITH_LUDII)
find_package(JNI)
if (JNI_FOUND)
include_directories( ${JNI_INCLUDE_DIRS})
else()
message(STATUS "Java not found, LUDII support will not be included")
add_definitions(-DNO_JAVA)
endif()
else()
add_definitions(-DNO_JAVA)
endif()
message(STATUS "Adding PyTorch compilation flags: ${TORCH_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
add_subdirectory(src)
# add Minesweeper benchmarks
add_subdirectory(src/games/minesweeper_csp_vkms)
# tests
add_executable(test_state src/core/test_state.cc src/core/state.cc)
target_link_libraries(test_state PUBLIC _tube _mcts _games ${JNI_LIBRARIES})
enable_testing()
add_test(NAME test_replay_buffer
COMMAND ${PYTHON_EXECUTABLE} -m test_replay_buffer
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/python)
set_tests_properties(test_replay_buffer
PROPERTIES ENVIRONMENT "PYTHONPATH=${PROJECT_SOURCE_DIR}:$ENV{PYTHONPATH}")
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to make participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, sex characteristics, gender identity and expression,
level of experience, education, socio-economic status, nationality, personal
appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies within all project spaces, and it also applies when
an individual is representing the project or its community in public spaces.
Examples of representing a project or community include using an official
project e-mail address, posting via an official social media account, or acting
as an appointed representative at an online or offline event. Representation of
a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at <opensource-conduct@fb.com>. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see
https://www.contributor-covenant.org/faq
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) Facebook, Inc. and its affiliates.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
[](https://circleci.com/gh/facebookincubator/Polygames)
# Polygames
This README is a work in progress, please feel very free to post issues - we are happy to help.
Save up computational power: you can find checkpoints here: http://dl.fbaipublicfiles.com/polygames/checkpoints/list.txt (feel free to open an issue for discussing which checkpoint you should use for which game/problem!).
For Nix users: see [this doc](./nix/README.md).
## Requirement:
```
C++17 compatible compiler
miniconda3
```
## Compilation Guide:
### First install conda and pytorch
Create a fresh conda environment with python3.7, install pytorch and dependencies.
```
# create a fresh conda environment with python3
# you will need to have miniconda3 set up
conda create --name [your env name] python=3.7 pip
conda activate [your env name] # Or source activate [your env name], depending on conda version.
conda install numpy pyyaml mkl mkl-include setuptools cmake cffi typing
conda install pytorch cudatoolkit=10.1 -c pytorch
conda install -c conda-forge tensorboardx
conda install -c conda-forge openjdk # optional
conda install -c conda-forge graphviz # optional
pip install visdom
pip install torchviz # optional
```
### Clone the repo and build
```
git clone --recursive https://github.com/facebookincubator/polygames
cd polygames
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=relwithdebinfo -DPYTORCH15=ON
make -j
```
Ludii support can be disabled by appending `-DWITH_LUDII=OFF` to the cmake command (required if you don't have jdk)
## Content
The repo contains mostly the following folders:
- the `pypolygames` python package, which serves as an entry point for the application
- the `src` folder, containing all C++ source code and third party libraries
- the `src/games` folder, containing the games coded in C++
## How to use the application
The application is launched from the `pypolygames` python package, in either of the following modes:ar
- `pypolygames train` (training mode): a game and a model (as well as several other options, see below) are chosen and the model is iteratively trained with MCTS
- `pypolygames eval` (evaluation mode): the model confronts either a pure MCTS or another neural network powered MCTS. The evaluation of a training can be done either offline (from checkpoints periodically saved) or in real time; in that case, the evaluation considers only the most recent checkpoint in order to follow closely the training, skipping some checkpoints in case the eval computation takes longer than the time becween consecutive checkpoints. It is displayed through visdom.
- `pypolygames traineval` (training + evaluation mode): it mixes the two previous modes and allow to launch one command instead of two. With the `real_time` option the modes can be launched in parallel instead of sequentially.
- `pypolygames human` (human mode): a human player plays against the machine
When a training is launched, it creates a `game_GAMENAME_model_MODELNAME_feat_FEATURIZATION_GMT_YYYYMMDDHHMMSS` within the `save_dir` where it will log relevant files:
- `model.pt`
- `train.log`
- `stat.tb`
- `checkpoints_EPOCH.pt` for for checkpoints saved each `saving_period` epoch (e.g., if `saving_period == 10`, `checkpoints_0.pt`, `checkpoints_10.pt`, `checkpoints_20.pt`, `checkpoints_30.pt`)
This directory will be the `checkpoint_save_dir` directory used by evaluation to retrieve the checkpoints to perform eval computation.
### Parameters
The list of parameters for each mode is available with
```
python -m pypolygames {train,eval,traineval,human} --help
```
#### Threads
In train (resp. eval) mode, `num_game * num_actor` (resp. `num_game * num_actor_eval * num_actor_opponent`) is the total number of threads. The more `num_actor` (and `num_actor_eval`, `num_actor_opponent`), the larger the MCTS is for a given player.
In human mode, since `num_game` is set to one, for leveraging the computing power available on the platform, a rule-of-thumb is to set `num_actor` to 5 times the number of CPUs available (it is platform-dependent though, and performance tests should be done).
### Model zoo
All models can be found in `pypolygames/model_zoo`. They come with a set of sensible parameters that can be customized as well as default games.
Usually models come in pair: `MODELNAMEFCLogitModel` and `MODELNAMEConvLogitModel`:
- `FCLogit` models use a fully-connected layer for logit inference and are compatible with all games
- `ConvLogit` models use a convolutional layer for logit inference and are only compatible with games whose action space if of same dimensions than their input space (an exception will be raised in case of an attempt to use an incompatible game)
So far the models being implemented are the folling:
- `GenericModel`: generic model compatible with all games, default when no `model_name` is specified
- `NanoFCLogitModel`: a simple model with a logit-inference fully-connected layer
- `NanoConvLogitModel`: a simple model with a logit-inference convolutional layer
- `ResConvFCLogitModel`: resnets with a logit-inference fully-connected layer
- `ResConvConvLogitModel`: resnets with a logit-inference convolutional layer
- `UConvFCLogitModel`: unets (direct paths between first and last layers) with a logit-inference fully-connected layer
- `UConvConvLogitModel`: unets (direct paths between first and last layers) with a logit-inference convolutional layer
- `AmazonsModel`: only for the Amazons game
Depending on the actual model chosen, some parameters might not have any use.
### Featurization
```
--out_features=True: the input to the NN includes a channel with 1 on the frontier.
--turn_features=True: the input to the NN includes a channel with the player index broadcasted.
--geometric_features=True: the input to the NN includes 4 geometric channels representing the position on the board.
--random_features=4: the input to the NN includes 4 random features.
--one_feature=True: the input to the NN includes a channel with 1 everywhere.
--history=3: the representation from the last 3 steps is added in the featurization.
```
### Examples
Run the following command before running the code
```
export OMP_NUM_THREADS=1
```
#### Examples for the training mode
- Launch the game `Connect4` with the `GenericModel`
```
python -m pypolygames train --game_name="Connect4"
```
- Launch a game with a specific model and specific parameters
```
python -m pypolygames train --game_name="Connect4" --out_features=True \
--model_name="UConvFCLogitModel" \
--nnsize=16 \
--nnks=3 \
--pooling
```
- Save checkpoints every 20 epochs in a specific folder
```
python -m pypolygames train --game_name="Connect4" --model_name="UConvFCLogitModel" \
--saving_period=20 \
--save_dir="/checkpoints"
```
- Run training on GPU for a max time
```
python -m pypolygames train --game_name="Connect4" --model_name="UConvFCLogitModel" \
--device="cuda:0" \
--max_time=3600
```
- Resume training from a given epoch
```
python -m pypolygames train \
--save_dir="/checkpoints/game_Connect4_model_GenericModel_feat..._GMT_20190717103728" \
--init_epoch=42
```
- Initiate from a pretrained model
```
python -m pypolygames train --init_checkpoint="path/to/pretrained_model.pt" \
--lr=0.001
```
Note that any checkpoint can serve as a pretrained model
- Train on multiple GPUs
```
python -m pypolygames train --init_checkpoint "path/to/pretrained_model.pt" \
--device cuda:0 cuda:1 cuda:2 cuda:3 cuda:4
```
In this case `cuda:0` will be used for training the model while `cuda:1`, `cuda:2` and `cuda:3` will be used for generating games. If there is only one device specified, it will be used for both purposes.
Notes:
- By default, the number of threads used for processing and batch sizes for inference are set automatically. These can be overriden with `num_thread` and `per_thread_batchsize` respectively.
- `num_game` specifies the number of "master" threads scheduling games, and the total number of games being run in parallel will be `num_game * per_thread_batchsize`. Since `per_thread_batchsize` is automatically determined by default, this could be a large number in some instances.
#### Examples for the evaluation mode
- Run offline evaluation
```
python -m pypolygames eval \
--checkpoint_dir="/checkpoints/game_Connect4_model_GenericModel_feat..._GMT_20190717103728"
```
- Plot evaluation on `http://localhost:10000` as the same time as training happens (training needs to be run from another process)
```
python -m pypolygames eval \
--checkpoint_dir="/checkpoints/game_Connect4_model_GenericModel_feat..._GMT_20190717103728" \
--real_time \
--plot_enabled \
--plot_port=10000
```
- Run evaluation on cpu with 100 games per evaluation, the pure-MCTS opponent playing 1000 rollouts while the model plays 400 rollouts
```
python -m pypolygames eval \
--checkpoint_dir="/checkpoints/game_Connect4_model_GenericModel_feat..._GMT_20190717103728" \
--device_eval="cpu" \
--num_game_eval=100 \
--num_rollouts_eval=400 \
--num_actor_eval=8 \
--num_rollouts_opponent=1000 \
--num_actor_opponent=8
```
- A specific checkpoint plays against another neural-network-powered MCTS
```
python -m pypolygames eval \
--checkpoint="/checkpoints/checkpoint_600.zip" \
--num_rollouts_eval=400 \
--num_actor_eval=8 \
--checkpoint_opponent="/checkpoints/checkpoint_200.zip" \
--num_rollouts_opponent=1000 \
--num_actor_opponent=8
```
- Four GPUs are used for evaluating the model, all for inference
```
python -m pypolygames eval \
--checkpoint="/checkpoints/checkpoint_600.zip" \
--device_eval cuda:0 cuda:1 cuda:2 cuda:3 \
--num_rollouts_eval=400 \
--num_actor_eval=8 \
--num_rollouts_opponent=1000 \
--num_actor_opponent=8
```
Notes:
- `num_actor_eval`, `num_rollouts_eval`, `num_actor_opponent` and `num_rollouts_opponent` are independent from the values used during training; in particular for proper benchmarking `num_actor_eval` and `num_rollouts_eval` should be set to the values used in human mode
- `num_game_eval * num_actor_eval` (resp. `num_game_eval * num_actor_opponent`) is the number of threads used by the model to be evaluated (resp. the opponent)
- there is no `per_thread_batchsize` in this mode
- the higher `num_actor_eval` (resp. `num_actor_opponent`), the larger MCTS for a move in a given game will be, up to a limit where overheads between threads lead to decreasing returns. Empiracally this limit seems to be around 8. This limit may be game/model/platform dependent and should be tuned for a given instance.
- against a pure MCTS opponent, `num_rollouts_opponent` should be set significantly higher than `num_rollouts_eval`
#### Examples for the training+evaluation mode
- Run first training then evaluation on the last checkpoint
```
python -m pypolygames traineval --game_name="Connect4" \
--save_dir="/checkpoints" \
--num_epoch=1000
```
- Plot evaluation on `http://localhost:10000` as the same time as training happens
```
python -m pypolygames traineval --game_name="Connect4" \
--save_dir="/checkpoints" \
--real_time \
--plot_enabled \
--plot_port=10000
```
#### Examples for the human mode
- Play to Connect4 against a pure MCTS as the second player with 8 threads
```
python -m pypolygames human --game_name="Connect4" \
--pure_mcts \
--num_actor 8
```
- Play to Connect4 against a pretrained model as the second player
```
python -m pypolygames human \
--init_checkpoint="/checkpoints/checkpoint_600.zip" \
--human_first
```
- Play with a timer, each side having 1800s in total, and the model playing each move with 0.07 of the remaining time
```
python -m pypolygames human \
--init_checkpoint="/checkpoints/checkpoint_600.zip" \
--total_time=1800 \
--time_ratio=0.07
```
- The model uses four GPUs, all for inference
```
python -m pypolygames human \
--init_checkpoint "/checkpoints/checkpoint_600.zip" \
--device cuda:0 cuda:1 cuda:2 cuda:3
```
- The model uses four GPUs, all for inference, and uses the text protocol (actions are represented by x y z, each on one line):
```
python -m pypolygames tp \
--init_checkpoint "/checkpoints/checkpoint_600.zip" \
--device cuda:0 cuda:1 cuda:2 cuda:3
```
Notes:
- in human mode, the model being fixed, the goal is to maximize performance given the platform running the model
- the most effective way to improve model performance is to increase the MCTS size
- as for training and evaluation, but given that there is only one game played, `num_actor` is the total number of threads
- the higher `num_actor`, the larger the MCTS, up to a limit where overheads between threads lead to decreasing returns. Empiracally this limit seems to be around 8. This limit may be game/model/platform dependent and should be tuned for a given instance.
- in a time-limited game `num_rollouts` should not be specified as it is maximized within each `time_ratio` * remaining time period
### Examples for converting models
Saved checkpoints of models also store details about the game for which they were trained, and can only be used directly for the
game in which they were trained. This is why `eval` runs do not require the `--game_name` to be specified; this is inferred from
the model. The `pypolygames convert` command can be used to convert models to different games.
- Fully automated convert between games:
```
python -m pypolygames convert \
--init_checkpoint "/checkpoints/checkpoint_600.pt.gz" \
--game_name="LudiiGomoku.lud" \
--out="/checkpoints/converted/XToGomoku.pt.gz"
```
This takes the previously-trained model stored in `"/checkpoints/checkpoint_600.pt.gz"`,
modifies it such that it can be used to play the Ludii implementation of Gomoku, and stores
this modified version of the model in the new file `"/checkpoints/converted/XToGomoku.pt.gz"`.
This works best when using neural network architectures that are compatible with arbitrary
board shapes (such as `ResConvConvLogitPoolModel`), and source and target games that have
identical numbers of channels for state and move tensors, as well as identical semantics for
those channels. For instance, the Ludii implementation of Yavalath has the same number of
channels with identical semantics (in the same order) as Gomoku. Therefore, if the source model
in `"/checkpoints/checkpoint_600.pt.gz"` was trained using `--model_name=ResConvConvLogitPoolModel`
and `--game_name="LudiiYavalath.lud"`, this conversion can be performed directly without having
to delete any parameters or add any new parameters.
- Fully automated convert between game options:
```
python -m pypolygames convert \
--init_checkpoint "/checkpoints/checkpoint_600.pt.gz" \
--game_options="Board Size/19x19" \
--out="/checkpoints/converted/Gomoku/15x15_to_19x19.pt.gz"
```
This example will convert the source checkpoint `"/checkpoints/checkpoint_600.pt.gz"`
into a model that can be used in a game loaded with the additional
`--game_options="Board Size/19x19"` argument. For example, `--game_name=LudiiGomoku.lud`
is by default played on a 15x15 board, but can be played on a larger 19x19 board with
the `--game_options="Board Size/19x19"` argument.
Note that the convert command only takes game options into account if some form of
`--game_options` is explicitly provided among the command line arguments. This means that, if
a model was first trained for `--game_options=Board Size/19x19`, and the goal is to convert
it into one for the default board size of 15x15, it is still necessary to provide either
`--game_options` (without any values after it) or `--game_options=Board Size/15x15`
to the convert script. This tells it that the goal is indeed to revert to default options,
rather than just leaving whichever options were baked into the source model.
### Examples for generating figures of models
If the optional `graphviz` and `torchviz` dependencies are installed, we can use `torchviz`
to automatically generate figures of our models. This can be done using `draw_model` script:
```
python -m pypolygames draw_model \
--game_name="Hex5pie" \
--model_name="ResConvConvLogitPoolModelV2" \
--out="/private/home/$USER/ImageName"
```
This command will generate an image of the `ResConvConvLogitPoolModelV2`
architecture when playing `Hex5pie`, and save it to `/private/home/$USER/ImageName.png`
(note that the `.png` extension will be automatically appended).
Any arguments that can be used to modify the game, or any aspect of the Neural Network
architecture, can be used in this command.
### Running games through Ludii
See [detailed documentation on the Ludii integration here](./src/games/ludii/).
## Contributing
We welcome contributions! Please check basic instructions [here](.github/CONTRIBUTING.md)
## Initial contributors
Contributors to the early version of Polygames (before open source release) include:
Tristan Cazenave, Univ. Dauphine; Yen-Chi Chen, National Taiwan Normal University; Guan-Wei Chen, National Dong Hwa University; Shi-Yu Chen, National Dong Hwa University; Xian-Dong Chiu, National Dong Hwa University; Julien Dehos, Univ. Littoral Cote d’Opale; Maria Elsa, National Dong Hwa University; Qucheng Gong, Facebook AI Research; Hengyuan Hu, Facebook AI Research; Vasil Khalidov, Facebook AI Research; Chen-Ling Li, National Dong Hwa University; Hsin-I Lin, National Dong Hwa University; Yu-Jin Lin, National Dong Hwa University; Xavier Martinet, Facebook AI Research; Vegard Mella, Facebook AI Research; Jeremy Rapin, Facebook AI Research; Baptiste Roziere, Facebook AI Research; Gabriel Synnaeve, Facebook AI Research; Fabien Teytaud, Univ. Littoral Cote d’Opale; Olivier Teytaud, Facebook AI Research; Shi-Cheng Ye, National Dong Hwa University; Yi-Jun Ye, National Dong Hwa University; Shi-Jim Yen, National Dong Hwa University; Sergey Zagoruyko, Facebook AI Research
## License
`polygames` is released under the MIT license. See [LICENSE](LICENSE) for additional details about it.
Third-party libraries are also included under their own license.
================================================
FILE: build.sh
================================================
#!/bin/sh
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
export OMP_NUM_THREADS=1
mkdir -p build
cd build
cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=1
make -j $(($(nproc) + 1))
cd ..
================================================
FILE: littlegolem/play_littlegolem.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import requests
from time import sleep
from bs4 import BeautifulSoup
import argparse
import os
def lg_connect(thelogin, thepassword):
''' Send login request and get session/login cookies. '''
myresponse = requests.post("https://www.littlegolem.net/jsp/login/index.jsp",
data = {'login': thelogin, 'password': thepassword})
if myresponse.status_code != requests.codes.ok:
raise ConnectionError("failed to request littlegolem (lg_connect)")
if not 'login2' in myresponse.cookies:
raise ConnectionError("failed to connect as '{}' (lg_connect)".format(thelogin))
return myresponse.cookies
def lg_clean_str(thestr):
''' Remove \t, \n, \r and # in a string. '''
return thestr.translate({ord(c): None for c in '\t\n\r#'})
def lg_get_onmove_games(thecookies):
''' Get the list of games "on move". Return a list [(game id, game name)]. '''
myresponse = requests.get("http://www.littlegolem.net/jsp/game/",
cookies = thecookies)
if myresponse.status_code != requests.codes.ok:
raise ConnectionError("failed to request littlegolem (lg_get_onmove_games)")
myhtml = BeautifulSoup(myresponse.text, "html.parser")
mydivs = myhtml.select("div.portlet.box.blue-madison")
if not mydivs:
return []
mytrs = mydivs[0].select("tbody")[0].select("tr")
return [ (lg_clean_str(mytds[0].a.text), mytds[4].text)
for mytds in (mytr.select("td") for mytr in mytrs) ]
def lg_get_hsgf(thegid):
''' Get the description of a game, in the hsgf format. '''
myurl = "http://www.littlegolem.net/servlet/sgf/{}/game{}.hsgf".format(thegid, thegid)
myresponse = requests.get(myurl)
if myresponse.status_code != requests.codes.ok:
raise ConnectionError("failed to request littlegolem (lg_get_hsgf)")
#import pdb;pdb.set_trace()
return myresponse.text
def lg_play(thecookies, thegid, themove):
myurl = "http://www.littlegolem.net/jsp/game/game.jsp?sendgame={}&sendmove={}".format(thegid, themove)
myresponse = requests.post(myurl, cookies = thecookies)
if myresponse.status_code != requests.codes.ok:
raise ConnectionError("failed to request littlegolem (lg_play)")
def einstein_convert_txt_to_polygames(myhsgf, gid):
#requests.get("http://www.littlegolem.net/jsp/game/game.jsp?gid=2127403").text
myurl = "http://www.littlegolem.net/jsp/game/game.jsp?gid={}".format(gid)
myresponse = requests.get(myurl)
if myresponse.status_code != requests.codes.ok:
raise ConnectionError("failed to request littlegolem (einstein html)")
myhtml = BeautifulSoup(myresponse.text, "html.parser")
imgs = myhtml.select("img")
assert(len(imgs) == 32)
# 2 is dice img
# 3-27 is number img
num_myhsgf = len(myhsgf.split("/"))
turn = num_myhsgf % 2
dice = int(imgs[2]['src'][28])
assert(dice >= 1 and dice <= 6)
state_str = ""
for i in range(25):
current = None
num_img = imgs[i + 3]['src']
color = None
num = None
if len(num_img) < 27:
color = num_img[18]
else:
color = num_img[27]
num = num_img[29]
if color == 'b':
current = chr(ord("A") + int(num) - 1)
elif color == 'r':
current = chr(ord("a") + int(num) - 1)
elif color == '0':
current = "0"
else:
print("parse image error, unexpected color")
assert(False)
state_str += current
s = ""
s += str(dice) + "\n" #input dice value
s += "m\n" # we switch to manual mode
s += "singlemovemode\n" # make one move, print it, exit
s += "set_" + state_str + str(turn) + "\n" # set state string
if turn == 0: # By default we assume that we play first.
s += "swap\n" # Please note that this has nothing to do with the pie rule.
s += "c\n" # Resume; this is the genmove.
s += str(dice) + "\n" #input dice value (unused)
#s += "exit\n" # Safety exit
return s, state_str, dice, turn
#[Event "Tournament null"]
#[Site "www.littlegolem.net"]
#[White "luffy_bot"]
#[Black "gzero_bot"]
#[Result "0-1"]
#1. h2-g3 e7-e6 2. a2-b3 g7-f6 3. b3-c4 f6-e5 4. f2-e3 b7-c6 5. g3-f4 f7-f6 6. g2-f3 h7-g6 7. e1-f2 a7-b6 8. h1-g2 b6-c5 9. d2-c3 h8-g7 10. c2-d3 e8-f7 11. b2-b3 c7-d6 12. b3-b4 a8-b7 13. d3-d4 c5xd4 14. c3xd4 g6-g5 15. f2-g3 g7-g6 16. b4-a5 c6-c5 17. d4xc5 d6xc5 18. d1-d2 d7-c6 19. f3-e4 g6-f5 20. e2-f3 f7-g6 21. a1-b2 d8-c7 22. b2-c3 g6-h5 23. e4xf5 e6xf5 24. d2-d3 h5-h4 25. g3xh4 e5xf4 26. resign 0-1
def breakthrough_convert_txt_to_polygames(txt):
turn = 0
last_action = None
s = "m\n" # we switch to manual mode
s += "singlemovemode\n" # make one move, print it, exit
elements = txt.split(".")
swapped = False
print(txt)
for e in elements:
if e[0] != " ":
continue
if e[2:] == "resign])":
s += "exit\n" # We stop everything.
continue
if len(e) < 6 or (e[3] != "-" and e[3] != "x"):
continue
es = e.split()
e0 = es[0]
e1 = es[1]
#print(e0)
#print(e1)
y = ord(e0[0]) - ord('a')
z = 8 - int(e0[1])
x = ord(e0[3]) - ord('a') - y + 1
last_action = str(x) + str(y) + str(z)
s += last_action + "\n"
turn = 1 - turn
if e1 == "*":
continue
else:
y = ord(e1[0]) - ord('a')
z = 8 - int(e1[1])
x = ord(e1[3]) - ord('a') - y + 1
last_action = str(x) + str(y) + str(z)
s += last_action + "\n"
turn = 1 - turn
if turn == 0: # By default we assume that we play first.
s += "swap\n" # Please note that this has nothing to do with the pie rule.
s += "c\n" # Resume; this is the genmove.
s += "exit\n" # Safety exit
#print("turn is" + str(turn))
return s, swapped, turn
def hex_convert_hsgf_to_polygames(hsgf):
turn = 0
last_action = None
s = "m\n" # we switch to manual mode
s += "singlemovemode\n" # make one move, print it, exit
elements = hsgf.split(";")
swapped = False
print(hsgf)
for e in elements:
if e[2:] == "resign])":
s += "exit\n" # We stop everything.
continue
if len(e) < 5:
continue
if e[2:6] == "swap":
# swap is implemented differently in littlegolem and polygames.
# we convert by flipping all remaining moves along the long diagonal.
swapped = True
s += last_action + "\n"
turn = 1 - turn
continue
if (e[0] == "W" or e[0] == "B") and e[1] == "[" and e[4] == "]":
x = ord(e[2]) - ord('a')
y = ord(e[3]) - ord('a')
if swapped:
x, y = y, x
last_action = chr(ord('a') + x) + str(1 + y)
s += last_action + "\n" # Swap is implemented as replaying the last action in Hex.
turn = 1 - turn
if turn == 0: # By default we assume that we play first.
s += "swap\n" # Please note that this has nothing to do with the pie rule.
s += "c\n" # Resume; this is the genmove.
s += "exit\n" # Safety exit
return s, swapped, last_action
#(;FF[4]EV[null]PB[leela_bot]PW[gzero_bot]SZ[13]RE[B]GC[ game #2103276]
#SO[http://www.littlegolem.com];W[ma];B[swap];W[jd];B[ej];W[ji];B[if];
#W[ck];B[ed];W[di];B[he];W[hf];B[ie];W[dd];B[ec];W[cc];B[cj];W[ef];B[dl];
#W[ke];B[jg];W[cl];B[dj];W[le];B[kd];W[je];B[lf];W[ig];B[jf];W[hg];B[db];
#W[ff];B[hb];W[cb];B[resign])
def havannah_convert_hsgf_to_polygames(hsgf, boardsize):
turn = 0
last_action = None
s = "m\n" # we switch to manual mode
s += "singlemovemode\n" # make one move, print it, exit
elements = hsgf.split(";")
swapped = False
print(hsgf)
for e in elements:
if e[2:] == "resign])":
s += "exit\n" # We stop everything.
continue
if len(e) < 5:
continue
if e[2:6] == "swap":
# swap is implemented differently in littlegolem and polygames.
# we convert by flipping all remaining moves along the long diagonal.
swapped = True
s += last_action + "\n"
turn = 1 - turn
continue
if (e[0] == "W" or e[0] == "B") and e[1] == "[" and (e[4] == "]" or e[5] == "]"):
# in littlegolem x, y = y, x in polygames
x = int(e[3])
if (e[4] != "]"):
x = int(e[3:5])
y = ord(e[2]) - ord('A')
v = 1
if (y >= boardsize):
v = y - boardsize + 2
last_action = str((x * -1)+(boardsize*2-v)) + "," + str(y)
s += last_action + "\n" # Swap is implemented as replaying the last action in Hex.
turn = 1 - turn
if turn == 0: # By default we assume that we play first.
s += "swap\n" # Please note that this has nothing to do with the pie rule.
s += "c\n" # Resume; this is the genmove.
s += "exit\n" # Safety exit
return s, swapped, last_action
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Play polygames on littlegolem.')
parser.add_argument('--username', type=str, help='Username for login')
parser.add_argument('--password', type=str, help='Password for login')
parser.add_argument('--hex11_model', type=str, help='Model to use for playing hex11pie')
parser.add_argument('--hex13_model', type=str, help='Model to use for playing hex13pie')
parser.add_argument('--havannah8_model', type=str, help='Model to use for playing havannah8pie')
parser.add_argument('--breakthrough_model', type=str, help='Model to use for playing breakthrough')
parser.add_argument('--havannah10_model', type=str, help='Model to use for playing havannah10pie')
parser.add_argument('--einstein_model', type=str, help='Model to use for playing einstein')
args = parser.parse_args()
try:
mylogin = args.username
mypassword = args.password
mycookies = lg_connect(mylogin, mypassword)
mygames = lg_get_onmove_games(mycookies)
except ConnectionError as e:
print("error:", e)
exit(1)
if not mygames:
print("no turn to play")
else:
played = []
not_played = []
for mygame in mygames:
try:
(mygid, mygname) = mygame
print("playing game #{} ({})...".format(mygid, mygname))
myhsgf = lg_get_hsgf(mygid)
#if "river" not in myhsgf: # uncomment this if you want to play only against someone with "river" in the name
# # (e.g. rookDriver, a.k.a the other Teytaud)
# print("I do not play ", myhsgf)
# not_played.append(mygname)
# continue
print("I play ", myhsgf)
resign_score = -0.99
model_path = None
swapped = False
last_action = None
turn = None
state_str = None
dice = None
if mygname == "Hex Size 11" and args.hex11_model:
polygames_commands, swapped, last_action = hex_convert_hsgf_to_polygames(myhsgf)
model_path = args.hex11_model
elif mygname == "Hex Size 13" and args.hex13_model:
polygames_commands, swapped, last_action = hex_convert_hsgf_to_polygames(myhsgf)
model_path = args.hex13_model
elif mygname == "Havannah Size 8" and args.havannah8_model:
polygames_commands, swapped, last_action = havannah_convert_hsgf_to_polygames(myhsgf, 8)
model_path = args.havannah8_model
elif mygname == "Breakthrough Size 8" and args.breakthrough_model:
polygames_commands, swapped, turn = breakthrough_convert_txt_to_polygames(myhsgf)
model_path = args.breakthrough_model
elif mygname == "Havannah Size 10" and args.havannah10_model:
polygames_commands, swapped, last_action = havannah_convert_hsgf_to_polygames(myhsgf, 10)
model_path = args.havannah10_model
elif mygname[:7] == "havannah"[:7] and "ize 8" in mygname and args.havannah8_model:
polygames_commands, swapped, last_action = havannah_convert_hsgf_to_polygames(myhsgf, 8)
model_path = args.havannah8_model
elif mygname[:7] == "havannah"[:7] and "ize 10" in mygname and args.havannah10_model:
polygames_commands, swapped, last_action = havannah_convert_hsgf_to_polygames(myhsgf, 10)
model_path = args.havannah10_model
elif mygname[:8] == "EinStein würfelt nicht! 3-points match"[:8] and args.einstein_model:
#pass in gid to handle specially for Einstein. e.g. parse board and dice value from html
polygames_commands, state_str, dice, turn = einstein_convert_txt_to_polygames(myhsgf, mygid)
model_path = args.einstein_model
else:
not_played.append(mygname)
continue
played.append(mygname)
# 60 seconds per move. Human first. 8 threads.
# Singularity command line below might be old fashioned ?
# command = "singularity exec --nv --overlay overlay.img /checkpoint/polygames/polygames_190927.simg python -m pypolygames human --init_checkpoint " + model_path
command = "python -m pypolygames human --init_checkpoint " + model_path
command += " --total_time 60000 --time_ratio 0.01 --human_first --num_actor 8"
import subprocess
command = "echo -e \"" + polygames_commands.translate({ord(c): '\\n' for c in '\n'}) + "\" | " + command
print(command)
mcts_value = None
move = None
if mygname[:8] == "EinStein würfelt nicht! 3-points match"[:8]:
# Unfortunately EinStein game needs special handling
# Somehow if I put -e here it gets passed to the program, need to investigate
command = "echo" + command[7:]
#print(command)
result = subprocess.check_output(command, shell=True)
mcts_value = result.splitlines()[-2].decode()
move = result.splitlines()[-4].decode()
print(move)
move_tokens = move.split()
origin = move_tokens[-3]
origin_num = int(origin[1])
target = move_tokens[-1]
origin_idx = -1
for i in range(5):
for j in range(5):
idx = i * 5 + j
if ord(state_str[idx]) - ord('a') == origin_num - 1 and origin[0] == 'x':
origin_idx = idx
break
if ord(state_str[idx]) - ord('A') == origin_num - 1 and origin[0] == 'o':
origin_idx = idx
break
#print(origin_idx)
char0 = chr(4 - origin_idx % 5 + ord('a'))
char1 = chr(4 - origin_idx // 5 + ord('a'))
char2 = chr(ord('E') - ord(target[0]) + ord('a'))
char3 = chr(5 - int(target[1]) + ord('a'))
move = char0 + char1 + char2 + char3
else:
result = subprocess.check_output(command, shell=True)
# Maybe "cwd = '..' " ? not if we assume
# run from the root of polygames
#print(result)
(mcts_value, move) = [i.decode() for i in result.splitlines()[-2:]]
mcts_value = mcts_value.split(":")[-1]
print("MCTS value: " + mcts_value)
print("Making move: " + move)
print("in game " + mygname)
mymove = None
if mygname == "Hex Size 11" or mygname == "Hex Size 13":
print("playing hex")
x = ord(move[0]) - ord('a')
y = int(move[1:]) - 1
if swapped:
x, y = y, x # in littlegolem, swap is implemented by mirror move and not switching colors
mymove = chr(ord('a') + int(x)) + chr(ord('a') + int(y))
if last_action != None and last_action.lower() == move.lower():
mymove = "swap"
elif (mygname[:10] == "Havannah Size 8"[:10] or mygname[:4] == "havannah.in"[:4]) and "Size 8" in mygname:
print("playing havannah 8")
boardsize = 8 # ONLY FOR SIZE 8
listmove = move.split(',')
x = int(listmove[0])
y = int(listmove[1])
mymove = chr(ord('a') + y + boardsize - 1) + chr(ord('a') + x + boardsize - 1) # ,11
if last_action != None and last_action.lower() == move.lower():
mymove = "swap"
elif (mygname[:4] == "havannah.in"[:4] or mygname[:10] == "Havannah Size 10"[:10]) and "Size 10" in mygname:
print("playing havannah 10")
boardsize = 10 # ONLY FOR SIZE 10
listmove = move.split(',')
x = int(listmove[0])
y = int(listmove[1])
mymove = chr(ord('a') + y + boardsize - 5) + chr(ord('a') + x + boardsize - 5) # ,11
if last_action != None and last_action.lower() == move.lower():
mymove = "swap"
elif mygname == "Breakthrough Size 8":
boardsize = 8
listmove = move.split(',')
x = int(listmove[0])
y = int(listmove[1])
z = boardsize - int(listmove[2]) - 1
z1 = z + 1 if turn == 0 else z - 1
mymove = str(y) + str(z) + str(y + x - 1) + str(z1)
elif mygname[:8] == "EinStein würfelt nicht! 3-points match"[:8]:
mymove = move
else:
print("implement mymove for " + mygname)
exit(1)
mymove = mymove.lower()
# No resign in Einstein, due to the complications on LittleGolem.
# Anyway, in a multigame (i.e. the best of k games), resigning is complicated and can not save up much time.
if float(mcts_value) < resign_score and "nStein w" not in mygname:
print("Resigning!")
mymove = "resign"
print("Sending move " + mymove)
lg_play(mycookies, mygid, mymove)
except ConnectionError as e:
print("error:", e)
exit(1)
if len(played):
print("Made a move in ", played)
if len(not_played):
print("Did not make a move in ", not_played)
# requests: https://2.python-requests.org/en/master/
# beautifulsoup4: https://www.crummy.com/software/BeautifulSoup/bs4/doc/
================================================
FILE: nix/Dockerfile
================================================
# This Dockerfile configures a Debian system with Nix, builds Polygames and
# runs some tests. To build this docker image, run:
# `docker build -t polygames .`
###############################################################################
# Initialize the docker image. You can ignore this when installing on a real
# system.
###############################################################################
FROM debian:buster
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update -y
RUN apt-get install -y git curl sudo xz-utils
RUN useradd -ms /bin/bash -G sudo myuser
RUN echo "myuser ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
USER myuser
ENV USER="myuser"
ENV HOME="/home/myuser"
###############################################################################
# Install Nix.
###############################################################################
RUN curl https://nixos.org/releases/nix/latest/install | sh
# For docker only:
ENV PATH="$HOME/.nix-profile/bin/:$PATH"
# On a real system, yau have to run these two lines instead:
#RUN echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $HOME/.bashrc
#RUN source $HOME/.bashrc
###############################################################################
# Activate the cachix repo.
###############################################################################
RUN nix-env -iA nixpkgs.cachix
RUN cachix use polygames
###############################################################################
# Get Polygames.
###############################################################################
WORKDIR $HOME
RUN git clone https://github.com/facebookincubator/polygames.git
WORKDIR $HOME/Polygames
# On a real system with CUDA devices, you have to run `./nix/get-nvidia.sh`
# here.
###############################################################################
# Build Polygames.
###############################################################################
RUN mkdir $HOME/Polygames/build
WORKDIR $HOME/Polygames/build
RUN nix-shell ../nix/shell-cpu.nix --run "cmake -DPYTORCH12=ON .. ; make -j4"
###############################################################################
# Run unit-tests.
###############################################################################
RUN mkdir $HOME/Polygames/tests/build
WORKDIR $HOME/Polygames/tests/build
RUN nix-shell ../../nix/shell-cpu.nix --run "cmake .. ; make -j4 ; ./polygames-tests"
###############################################################################
# Run tests.
###############################################################################
WORKDIR $HOME/Polygames/
RUN nix-shell nix/shell-cpu.nix --run "pytest pypolygames --durations=10 --verbose"
================================================
FILE: nix/Dockerfile-centos7-nix
================================================
# docker build -t polygames-centos7-nix -f Dockerfile-centos7-nix .
# docker run --rm -it polygames-centos7-nix
# nix-shell nix/shell-cpu.nix --run "python -m pypolygames train --game_name Hex11 --device=cpu"
FROM centos:centos7
RUN yum update -y
RUN yum install -y git curl sudo xz-utils cacert
RUN useradd -ms /bin/bash -G wheel myuser
RUN echo "myuser ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
USER myuser
ENV USER="myuser"
ENV HOME="/home/myuser"
RUN curl https://nixos.org/releases/nix/latest/install | sh
RUN echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $HOME/.bashrc
RUN source $HOME/.bashrc
ENV PATH="$HOME/.nix-profile/bin/:$PATH#"
ENV NIX_SSL_CERT_FILE="/etc/ssl/certs/ca-bundle.crt"
RUN nix-env -iA nixpkgs.cachix
RUN cachix use polygames
WORKDIR $HOME
RUN git clone https://github.com/juliendehos/Polygames.git --branch=nix
RUN mkdir $HOME/Polygames/build
WORKDIR $HOME/Polygames/build
RUN nix-shell ../nix/shell-cpu.nix --run "cmake -DPYTORCH12=ON .. ; make -j4"
WORKDIR $HOME/Polygames/
================================================
FILE: nix/README.md
================================================
# Polygames for Nix users
[Nix](https://nixos.org/) is a package manager that can be installed on any
Linux distribution (you just need root permissions to create the `/nix`
directory). Alternatively, NixOS is a Linux distribution based on Nix.
Polygames is quite easy to use with Nix and NixOS, as explained below. See also
the [Dockerfile](./Dockerfile).
## Get Polygames
- Clone the repo:
```
git clone https://github.com/facebookincubator/polygames.git
cd Polygames
```
## Configure your system (NixOS)
- With NixOS, if you want to run Polygames on CPU, you have nothing to
configure.
- If you want to run Polygames on CUDA devices, check that the Nvidia driver is
enable in `/etc/nixos/configuration.nix` (don't forget to rebuild and reboot
the system, if necessary):
```
services.xserver.videoDrivers = [ "nvidia" ];
nixpkgs.config.allowUnfree = true;
```
## Configure your system (Nix + Linux)
- Install Nix:
```
curl https://nixos.org/releases/nix/latest/install | sh
echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $HOME/.bashrc
source $HOME/.bashrc
```
- If you want to run Polygames on CUDA devices:
- Install the Nvidia driver using your Linux distribution.
- Check that `nvidia-smi` is also installed.
- Get the Nvidia driver version and write the `nvidia.json` config file:
```
./nix/get-nvidia.sh
```
## Build & run Polygames
- Activate the binary cache (optional if you like compiling for hours):
```
nix-env -iA nixpkgs.cachix
cachix use polygames
```
> Warning: this cache provides pre-built binaries for CPU and for Nvidia
> 418.74 only but you can [build your own binary
> cache](README.md#build-you-own-binary-cache).
- Open a nix-shell:
- CPU:
```
nix-shell nix/shell-cpu.nix
```
- CUDA:
```
nix-shell nix/shell-cuda.nix
```
- Build Polygames:
```
mkdir build
cd build
cmake -DPYTORCH12=ON ..
make -j4
cd ..
```
- Run Polygames:
- CPU:
```
python -m pypolygames train --game_name="Connect4" --device=cpu
```
- CUDA:
```
python -m pypolygames train --game_name="Connect4" --device=cuda:0
```
## Build you own binary cache
When you open a nix-shell for the first time, Nix/NixOS fetches and builds all
the required dependencies. [This cachix repo](https://polygames.cachix.org/)
provides some pre-built dependencies that should greatly speed-up the
installation.
However, if your Nvidia driver version is not in the cache, you have to build
CUDA/Pytorch/etc. You can upload the built binaries to reuse them on other
machines:
- Create a (free) account on [cachix](https://cachix.org/).
- Create a repo on cachix.
- Push your binaries to this repo:
```
find /nix/store -maxdepth 1 -name "*pytorch*" -exec cachix push <my-cachix-repo> {} \;
```
- Use your repo when you install/configure Polygames on a new machine:
```
cachix use <my-cachix-repo>
```
================================================
FILE: nix/get-nvidia.sh
================================================
#!/bin/sh
nvidiaVersion=$(nvidia-smi --query-gpu=driver_version --format=csv | tail -n 1)
echo "detected: ${nvidiaVersion}"
nvidiaUrl="http://download.nvidia.com/XFree86/Linux-x86_64/${nvidiaVersion}/NVIDIA-Linux-x86_64-${nvidiaVersion}.run"
nvidiaSha256=$(nix-prefetch-url ${nvidiaUrl})
OUTNAME="nvidia.json"
echo "{" > ${OUTNAME}
echo " \"nvidiaVersion\" : \"${nvidiaVersion}\"," >> ${OUTNAME}
echo " \"nvidiaSha256\" : \"${nvidiaSha256}\"" >> ${OUTNAME}
echo "}" >> ${OUTNAME}
echo "${OUTNAME} written"
================================================
FILE: nix/shell-cpu.nix
================================================
let
rev = "dfa8e8b9bc4a18bab8f2c55897b6054d31e2c71b";
channel = fetchTarball "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz";
config = { allowUnfree = true; };
pkgs = import channel { inherit config; };
python = pkgs.python3;
pytorch = pkgs.python3Packages.pytorchWithoutCuda;
pybind11 = pkgs.pybind11;
tensorboardX = pkgs.python3Packages.buildPythonPackage rec {
pname = "tensorboardX";
version = "1.8";
src = fetchTarball "https://github.com/lanpa/tensorboardX/archive/v1.8.tar.gz";
propagatedBuildInputs = with pkgs.python3Packages; [
six
protobuf
numpy
];
doCheck = false;
};
in pkgs.mkShell {
name = "Polygames-cpu";
src = ./.;
buildInputs = [
pkgs.cmake
pkgs.czmq
pkgs.gtest
pkgs.python3Packages.pytest
pkgs.openjdk
pytorch
tensorboardX
];
shellHook = ''
export CFLAGS="-I${pybind11}/include -I${pytorch}/${python.sitePackages}/torch/include -I${pytorch}/${python.sitePackages}/torch/include/torch/csrc/api/include"
export CXXFLAGS=$CFLAGS
export LDFLAGS="-L${pytorch}/${python.sitePackages}/torch/lib -L$out/${python.sitePackages}"
export PYTHONPATH="$PYTHONPATH:build:build/torchRL/mcts:build/torchRL/tube"
export OMP_NUM_THREADS=1
'';
}
================================================
FILE: nix/shell-cuda.nix
================================================
let
jsonPath = ../nvidia.json;
hasJson = builtins.pathExists jsonPath;
json = builtins.fromJSON (builtins.readFile jsonPath);
overlay = self: super:
{
linuxPackages = super.linuxPackages //
{
nvidia_x11 = (super.linuxPackages.nvidia_x11.override {
}).overrideAttrs(oldAttrs: rec {
version = json.nvidiaVersion;
name = "nvidia-${version}";
src = super.fetchurl {
url = "http://download.nvidia.com/XFree86/Linux-x86_64/${version}/NVIDIA-Linux-x86_64-${version}.run";
sha256 = json.nvidiaSha256;
};
useGLVND = true;
});
};
};
rev = "dfa8e8b9bc4a18bab8f2c55897b6054d31e2c71b";
channel = fetchTarball "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz";
config = {
allowUnfree = true;
cudaSupport = true;
packageOverrides = pkgs: {
cudatoolkit = pkgs.cudatoolkit_10;
cudnn = pkgs.cudnn_cudatoolkit_10;
};
};
pkgs = import channel {
overlays = if hasJson then [overlay] else [];
inherit config;
};
python = pkgs.python3;
pytorch = pkgs.python3Packages.pytorchWithCuda;
pybind11 = pkgs.pybind11;
tensorboardX = pkgs.python3Packages.buildPythonPackage rec {
pname = "tensorboardX";
version = "1.8";
src = fetchTarball "https://github.com/lanpa/tensorboardX/archive/v1.8.tar.gz";
propagatedBuildInputs = with pkgs.python3Packages; [
six
protobuf
numpy
];
doCheck = false;
};
in pkgs.mkShell {
name = "Polygames-cuda";
src = ./.;
buildInputs = [
pkgs.boost
pkgs.cmake
pkgs.cudatoolkit
pkgs.cudnn
pkgs.czmq
pkgs.gtest
pkgs.linuxPackages.nvidia_x11
pkgs.python3Packages.pytest
pkgs.openjdk
pytorch
tensorboardX
];
shellHook = ''
export CFLAGS="-I${pybind11}/include -I${pytorch}/${python.sitePackages}/torch/include -I${pytorch}/${python.sitePackages}/torch/include/torch/csrc/api/include"
export CXXFLAGS=$CFLAGS
export LDFLAGS="-L${pytorch}/${python.sitePackages}/torch/lib -L$out/${python.sitePackages} -L${pkgs.cudatoolkit}/lib"
export LD_LIBRARY_PATH="${pkgs.linuxPackages.nvidia_x11}/lib"
export PYTHONPATH="$PYTHONPATH:build:build/torchRL/mcts:build/torchRL/tube"
export OMP_NUM_THREADS=1
'';
}
================================================
FILE: pypolygames/__init__.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import sys
# disable CUDA cache as it can throw errors when doing distributed
# training and the cache folder is on NFS
os.environ['CUDA_CACHE_DISABLE'] = '1'
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
game = os.path.join(root, "build/src")
if game not in sys.path:
sys.path.append(game)
tube = os.path.join(root, "build/src", "tube")
if tube not in sys.path:
sys.path.append(tube)
pytube = os.path.join(root, "src", "tube")
if pytube not in sys.path:
sys.path.append(pytube)
mcts = os.path.join(root, "build/src", "mcts")
if mcts not in sys.path:
sys.path.append(mcts)
================================================
FILE: pypolygames/__main__.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
from pathlib import Path
import sys
import warnings
import time
from dataclasses import astuple
import argparse
from multiprocessing import Process
from typing import Union, List
from .params import (
GameParams,
ModelParams,
OptimParams,
SimulationParams,
ExecutionParams,
EvalParams,
)
from .utils import CommandHistory
from .training import run_training
from .evaluation import run_evaluation
from .human import run_human_played_game
from .human import run_tp_played_game
from .convert import convert_checkpoint
from .draw_model import draw_model
DOC = """The python package `pypolygames` can be used in either of the following modes:
- `pypolygames train` (training mode): a game and a model (as well as several other options, see below) are chosen and the model is iteratively trained with MCTS
- `pypolygames eval` (evaluation mode): the model confronts either a pure MCTS or another neural network powered MCTS. The evaluation of a training can be done either offline (from checkpoints periodically saved) or in real time; in that case, the evaluation considers only the most recent checkpoint in order to follow closely the training, skipping some checkpoints in case the eval computation takes longer than the time becween consecutive checkpoints. It is displayed through visdom.
- `pypolygames traineval` (training + evaluation mode): it mixes the two previous modes and allow to launch one command instead of two. With the `real_time` option the modes can be launched in parallel instead of sequentially.
- `pypolygames human` (human mode): a human player plays against the machine
Trainings log the following relevant files in the `checkpoint_dir`:
- `model.pt`
- `train.log`
- `stat.tb`
- `checkpoints_<epoch>.pt` for for checkpoints saved each `saving_period` epoch (e.g., if `saving_period == 10`, `checkpoints_0.pt`, `checkpoints_9.pt`, `checkpoints_19.pt`, `checkpoints_29.pt`)
By default, the checkpoint_dir is exps/dev/game_<game_name>_model_<model_name>_feat_<featurization>_GMT_<YYYYMMDDHHMMSS>
This directory will be the `checkpoint_dir` directory used by evaluation to retrieve the checkpoints to perform eval computation."""
def _check_arg_consistency(args: argparse.Namespace) -> None:
# Most of the consistency is done in the `__post_init__` methods in the params class
if (
args.command_history.last_command_contains("pure_mcts")
and getattr(args, "game_name", None) is None
):
raise ValueError(
"In '--pure_mcts' the game must be specified with '--game_name'"
)
if args.command_history.last_command_contains("human"):
if (
getattr(args, "pure_mcts", None) is False
and getattr(args, "init_checkpoint", None) is None
):
raise ValueError(
"The human player need to play either a '--pure_mcts' "
"or a '--init_checkpoint' neural network powered MCTS"
)
if args.command_history.last_command_contains("device_opponent"):
if getattr(args, "checkpoint_opponent", None) is None:
raise ValueError(
"If the opponent is a pure MCTS player "
"('--checkpoint_opponent' not set), "
"all its computation will happen on CPU, "
"'--device_opponent' should not be set"
)
if args.command_history.last_command_contains(
"per_thread_batchsize"
) and args.command_history.last_command_contains("act_batchsize"):
raise ValueError(
"When '--per_thread_batchsize' is set, '--act_batchsize' is not used"
)
if getattr(args, "total_time", 0) is not None and getattr(args, "total_time", 0) > 0:
if args.command_history.last_command_contains("num_rollouts"):
raise ValueError(
"When a '--total_time' is set, "
"the '--num_rollouts' will adapt automatically and should not be set"
)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description=DOC, formatter_class=argparse.RawDescriptionHelpFormatter, allow_abbrev=False,
)
parser.set_defaults(func=run_training_and_evaluation_from_args_warning)
subparsers = parser.add_subparsers(
help="Modes to be chosen from: `python -m pypolygames MODE`"
)
# TRAINING
parser_train = subparsers.add_parser("train")
parser_train.set_defaults(func=run_training_from_args)
# EVALUATION
parser_eval = subparsers.add_parser("eval")
parser_eval.set_defaults(func=run_evaluation_from_args)
# TRAINING + EVALUATION
parser_traineval = subparsers.add_parser("traineval")
parser_traineval.set_defaults(func=run_training_and_evaluation_from_args)
# HUMAN-PLAYED GAME
parser_human = subparsers.add_parser("human")
parser_human.set_defaults(func=run_human_played_game_from_args)
# TEXT-PROTOCOLE GAME
parser_tp = subparsers.add_parser("tp")
parser_tp.set_defaults(func=run_tp_played_game_from_args)
# CONVERT CHECKPOINT COMMAND
parser_convert = subparsers.add_parser("convert")
parser_convert.set_defaults(func=convert_checkpoint_from_args)
parser_convert.add_argument('--out', type=str, required=True, help='File name to save the converted checkpoint to')
parser_convert.add_argument('--skip', type=str, nargs="*", help='List of attributes to not copy, leaving them initialized')
parser_convert.add_argument(
'--auto_tune_nnsize', action="store_true",
help='Tune nnsize automatically such that number of filters in hidden layers remains unchanged.'
)
parser_convert.add_argument(
'--zero_shot', type=bool, default=False,
help='Convert for zero-shot evaluation without training; this will initialise any skipped or new params to 0.'
)
parser_convert.add_argument(
'--move_source_channels', type=int, nargs="*",
help=('For fully convolutional architectures, for every channel in the destination game\'s move tensors, '
'specify the channel from the original tensor that we should transfer weights from.')
)
parser_convert.add_argument(
'--state_source_channels', type=int, nargs="*",
help=('For fully convolutional architectures, for every channel in the destination game\'s state tensors, '
'specify the channel from the original tensor that we should transfer weights from.')
)
# DRAW MODEL COMMAND
parser_draw_model = subparsers.add_parser("draw_model")
parser_draw_model.set_defaults(func=draw_model_from_args)
parser_draw_model.add_argument('--out', type=str, required=True, help='File name (without extension) to save figure to.')
# Game params
train_game_params_group = parser_train.add_argument_group(
"Game parameters",
"Not to be specified in case of loading a checkpoint or a pretrained model",
)
traineval_game_params_group = parser_traineval.add_argument_group(
"Game parameters",
"Not to be specified in case of loading a checkpoint or a pretrained model",
)
game_params_group = parser.add_argument_group(
"Game parameters",
"Not to be specified in case of loading a checkpoint or a pretrained model",
)
human_game_params_group = parser_human.add_argument_group(
"Game parameters",
"Mandatory for pure MTCS, "
"but not to be specified in case of loading a pretrained model",
)
for arg_name, arg_field in GameParams.arg_fields():
train_game_params_group.add_argument(arg_field.name, **arg_field.opts)
traineval_game_params_group.add_argument(arg_field.name, **arg_field.opts)
game_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
human_game_params_group.add_argument(arg_field.name, **arg_field.opts)
parser_convert.add_argument(arg_field.name, **arg_field.opts)
parser_draw_model.add_argument(arg_field.name, **arg_field.opts)
# Model params
train_model_params_group = parser_train.add_argument_group(
"Model parameters",
"Not to be specified in case of loading a checkpoint or a pretrained model",
)
traineval_model_params_group = parser_traineval.add_argument_group(
"Model parameters",
"Not to be specified in case of loading a checkpoint or a pretrained model",
)
model_params_group = parser.add_argument_group("Model parameters")
human_model_params_group = parser_human.add_argument_group(
"Model parameters",
"The machine model can be either a '--pure_mcts' or "
"a '--init_checkpoint' neural network powered MCTS",
)
for arg_name, arg_field in ModelParams.arg_fields():
if arg_name != "pure_mcts":
train_model_params_group.add_argument(arg_field.name, **arg_field.opts)
traineval_model_params_group.add_argument(arg_field.name, **arg_field.opts)
model_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
if arg_name in {"pure_mcts", "init_checkpoint"}:
human_model_params_group.add_argument(arg_field.name, **arg_field.opts)
if arg_name != "pure_mcts":
parser_convert.add_argument(arg_field.name, **arg_field.opts)
parser_draw_model.add_argument(arg_field.name, **arg_field.opts)
# Optimizer params
train_optim_params_group = parser_train.add_argument_group("Optimizer parameters")
traineval_optim_params_group = parser_traineval.add_argument_group(
"Optimizer parameters"
)
optim_params_group = parser.add_argument_group("Optimizer parameters")
for _, arg_field in OptimParams.arg_fields():
train_optim_params_group.add_argument(arg_field.name, **arg_field.opts)
traineval_optim_params_group.add_argument(arg_field.name, **arg_field.opts)
optim_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
# Simulation params
train_simulation_params_group = parser_train.add_argument_group(
"Simulation parameters"
)
traineval_simulation_params_group = parser_traineval.add_argument_group(
"Simulation parameters"
)
simulation_params_group = parser.add_argument_group("Simulation parameters")
human_simulation_params_group = parser_human.add_argument_group(
"Simulation parameters"
)
for arg_name, arg_field in SimulationParams.arg_fields():
if arg_name not in {
"human_first",
"time_ratio",
"total_time",
}: # , "num_actor"}:
train_simulation_params_group.add_argument(arg_field.name, **arg_field.opts)
traineval_simulation_params_group.add_argument(
arg_field.name, **arg_field.opts
)
simulation_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
#if arg_name in {"num_actor", "num_rollouts"}:
if True:
human_simulation_params_group.add_argument(arg_field.name, **arg_field.opts)
# Execution params
train_execution_params_group = parser_train.add_argument_group(
"Execution parameters"
)
traineval_execution_params_group = parser_traineval.add_argument_group(
"Execution parameters"
)
human_execution_params_group = parser_human.add_argument_group(
"Execution parameters"
)
execution_params_group = parser.add_argument_group("Execution parameters")
for arg_name, arg_field in ExecutionParams.arg_fields():
if arg_name not in {"human_first", "time_ratio", "total_time"}:
train_execution_params_group.add_argument(arg_field.name, **arg_field.opts)
traineval_execution_params_group.add_argument(
arg_field.name, **arg_field.opts
)
execution_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
if arg_name in {"human_first", "time_ratio", "total_time", "device", "seed"}:
human_execution_params_group.add_argument(arg_field.name, **arg_field.opts)
# Evaluation params
eval_eval_params_group = parser_eval.add_argument_group("Evaluation parameters")
traineval_eval_params_group = parser_traineval.add_argument_group(
"Evaluation parameters"
)
eval_params_group = parser.add_argument_group("Evaluation parameters")
for arg_name, arg_field in EvalParams.arg_fields():
eval_eval_params_group.add_argument(arg_field.name, **arg_field.opts)
if arg_name not in {"checkpoint_dir", "checkpoint"}:
traineval_eval_params_group.add_argument(arg_field.name, **arg_field.opts)
eval_params_group.add_argument(
arg_field.name, **{**arg_field.opts, **dict(help=argparse.SUPPRESS)}
)
args = parser.parse_args()
args.command_history = CommandHistory()
# check arg consistency
_check_arg_consistency(args)
return args
def _get_game_features(game_params: GameParams) -> str:
return "_".join(str(x) for x in astuple(game_params))
def _get_timestamp() -> str:
return time.strftime("%Y%m%d%H%M%S", time.gmtime())
def update_and_create_checkpoint_dir(
game_params: GameParams,
model_params: ModelParams,
execution_params: ExecutionParams,
) -> None:
# create a dedicated folder if none is provided
if execution_params.checkpoint_dir is None:
game_name = game_params.game_name
model_name = model_params.model_name
game_features = _get_game_features(game_params)
timestamp = _get_timestamp()
subfolder = f"game_{game_name}_model_{model_name}_feat_{game_features}_GMT_{timestamp}"
execution_params.checkpoint_dir = Path("exps").absolute() / "dev" / subfolder
execution_params.checkpoint_dir.mkdir(exist_ok=True, parents=True)
def instanciate_params_from_args(
Dataclass, args: argparse.Namespace
) -> Union[
GameParams, ModelParams, OptimParams, SimulationParams, ExecutionParams, EvalParams
]:
return Dataclass(
**{param: getattr(args, param, None) for param, _ in Dataclass.arg_fields()}
)
def run_training_from_args(args: argparse.Namespace):
command_history = args.command_history
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
optim_params = instanciate_params_from_args(OptimParams, args)
simulation_params = instanciate_params_from_args(SimulationParams, args)
execution_params = instanciate_params_from_args(ExecutionParams, args)
update_and_create_checkpoint_dir(
game_params=game_params,
model_params=model_params,
execution_params=execution_params,
)
run_training(
command_history=command_history,
game_params=game_params,
model_params=model_params,
optim_params=optim_params,
simulation_params=simulation_params,
execution_params=execution_params,
)
def run_evaluation_from_args(args: argparse.Namespace):
eval_params = instanciate_params_from_args(EvalParams, args)
execution_params = instanciate_params_from_args(ExecutionParams, args)
run_evaluation(eval_params=eval_params, execution_params=execution_params)
def run_training_and_evaluation_from_args(args: argparse.Namespace):
command_history = args.command_history
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
optim_params = instanciate_params_from_args(OptimParams, args)
simulation_params = instanciate_params_from_args(SimulationParams, args)
execution_params = instanciate_params_from_args(ExecutionParams, args)
# create the save dir
update_and_create_checkpoint_dir(
game_params=game_params,
model_params=model_params,
execution_params=execution_params,
)
args.checkpoint_dir = execution_params.checkpoint_dir
eval_params = instanciate_params_from_args(EvalParams, args)
if args.real_time:
eval_process = Process(target=run_evaluation, args=(eval_params,))
eval_process.start()
run_training(
command_history=command_history,
game_params=game_params,
model_params=model_params,
optim_params=optim_params,
simulation_params=simulation_params,
execution_params=execution_params,
)
eval_process.join()
else:
run_training(
command_history=command_history,
game_params=game_params,
model_params=model_params,
optim_params=optim_params,
simulation_params=simulation_params,
execution_params=execution_params,
)
run_evaluation(eval_params=eval_params, only_last=True)
def run_human_played_game_from_args(args: argparse.Namespace):
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
simulation_params = instanciate_params_from_args(SimulationParams, args)
simulation_params.num_game = 1
execution_params = instanciate_params_from_args(ExecutionParams, args)
run_human_played_game(
game_params=game_params,
model_params=model_params,
simulation_params=simulation_params,
execution_params=execution_params,
)
def run_tp_played_game_from_args(args: argparse.Namespace):
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
simulation_params = instanciate_params_from_args(SimulationParams, args)
simulation_params.num_game = 1
execution_params = instanciate_params_from_args(ExecutionParams, args)
run_tp_played_game(
game_params=game_params,
model_params=model_params,
simulation_params=simulation_params,
execution_params=execution_params,
)
def convert_checkpoint_from_args(args: argparse.Namespace):
command_history = args.command_history
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
convert_checkpoint(
command_history=command_history,
game_params=game_params,
model_params=model_params,
out=args.out,
skip=args.skip,
auto_tune_nnsize=args.auto_tune_nnsize,
zero_shot=args.zero_shot,
move_source_channels=args.move_source_channels,
state_source_channels=args.state_source_channels,
)
def draw_model_from_args(args: argparse.Namespace):
game_params = instanciate_params_from_args(GameParams, args)
model_params = instanciate_params_from_args(ModelParams, args)
draw_model(
game_params=game_params,
model_params=model_params,
out=args.out,
)
def run_training_and_evaluation_from_args_warning(args: argparse.Namespace):
# pypolygames called directly
if len(sys.argv) == 1:
print(DOC)
# otherwise default to traineval
else:
warnings.warn(
"'pypolygames' called with arguments runs as 'pypolygames traineval'",
DeprecationWarning,
)
run_training_and_evaluation_from_args(args)
if __name__ == "__main__":
args = parse_args()
args.func(args)
================================================
FILE: pypolygames/convert.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import time
from typing import Iterator, Tuple, Callable, Optional, List, Dict
from pathlib import Path
import copy
import torch
import polygames
from . import utils
from .model_zoo import utils as zutils
from .params import GameParams, ModelParams, SimulationParams, ExecutionParams
from .env_creation_helpers import (
sanitize_game_params,
create_model,
create_game,
create_player,
)
def convert_checkpoint(
command_history: utils.CommandHistory,
game_params: GameParams,
model_params: ModelParams,
out: str,
skip: List[str],
auto_tune_nnsize: bool,
zero_shot: bool,
move_source_channels: List[int],
state_source_channels: List[int],
):
checkpoint = utils.load_checkpoint(
checkpoint_path=model_params.init_checkpoint)
old_model_params = checkpoint["model_params"]
old_game_params = checkpoint["game_params"]
sanitize_game_params(old_game_params) # backwards compatibility for models without game_options
model_state_dict = checkpoint["model_state_dict"]
print(old_model_params.model_name)
print(getattr(old_model_params, "model_name"))
new_model_params = copy.deepcopy(old_model_params)
new_game_params = copy.deepcopy(old_game_params)
for k, v in vars(model_params).items():
if not command_history.last_command_contains(k) or k == "init_checkpoint":
continue
ov = getattr(new_model_params, k)
if v != ov:
print("Changing %s from %s to %s" % (k, ov, v))
setattr(new_model_params, k, v)
for k, v in vars(game_params).items():
if not command_history.last_command_contains(k):
continue
ov = getattr(new_game_params, k)
if v != ov:
print("Changing %s from %s to %s" % (k, ov, v))
setattr(new_game_params, k, v)
fix_global_pooling = old_model_params.model_name == "ResConvConvLogitPoolModelV2" and new_model_params.model_name == "ResConvConvLogitPoolModelV2" and new_model_params.global_pooling > 0
if fix_global_pooling:
print("Note: attempting to patch global pooling weights to match the new model")
if zero_shot:
print("Note: converting model for zero-shot evaluation only! Added/reinitialized params will be all 0 and untrainable!")
if auto_tune_nnsize or move_source_channels is not None or state_source_channels is not None:
# We'll need to load the game info
old_game_info = zutils.get_game_info(old_game_params)
new_game_info = zutils.get_game_info(new_game_params)
if auto_tune_nnsize:
# We want to automatically tune nnsize, such that the number
# of filters in hidden layers does not change from source to
# target model
c_old, _, _ = old_game_info["feature_size"][:3]
c_new, _, _ = new_game_info["feature_size"][:3]
new_nnsize = float((getattr(old_model_params, 'nnsize') * c_old) / c_new)
print("Auto-tuning nnsize to:", new_nnsize)
setattr(new_model_params, 'nnsize', new_nnsize)
if move_source_channels is not None:
c_action_new, _, _ = new_game_info["action_size"][:3]
if c_action_new != len(move_source_channels):
print("ERROR: if --move_source_channels is specified, it must have exactly c_action_new entries!")
print("c_action_new = ", c_action_new)
print("len(move_source_channels) = ", len(move_source_channels))
if state_source_channels is not None:
c_state_new, _, _ = new_game_info["feature_size"][:3]
if c_state_new != len(state_source_channels):
print("ERROR: if --state_source_channels is specified, it must have exactly c_state_new entries!")
print("c_state_new = ", c_state_new)
print("len(state_source_channels) = ", len(state_source_channels))
m = create_model(game_params=new_game_params,
model_params=new_model_params)
s = m.state_dict()
params_added = 0
params_removed = 0
params_reinitialized = 0
taken = []
for k, src in model_state_dict.items():
if not k in s:
moved = False
for k2, dst in s.items():
if not k2 in model_state_dict and src.shape == dst.shape and not k2 in taken:
print("%s shape %s moved to %s" % (k, src.shape, k2))
taken.append(k2)
dst.copy_(src)
moved = True
break
if not moved:
print("%s shape %s removed" % (k, src.shape))
params_removed += src.numel()
for k, dst in s.items():
if k in taken:
continue
if zero_shot:
dst = dst.fill_(0)
if skip is not None and k in skip:
print("%s shape %s skipped" % (k, dst.shape))
params_reinitialized += dst.numel()
continue
if not k in model_state_dict:
params_added += dst.numel()
continue
src = model_state_dict[k]
if move_source_channels is not None and "pi_logit." in k:
# Use manually specified channels to transfer from for
# last Conv2D operation that produces pi logits
if "weight" in k:
for i in range(len(move_source_channels)):
if move_source_channels[i] >= 0:
dst_view = dst
src_view = src
for j in range(dst_view.dim()):
if j == 0: # Don't narrow this dim, need original indexing
continue
if src_view.shape[j] > dst_view.shape[j]:
src_view = src_view.narrow(j, 0, dst_view.shape[j])
if dst_view.shape[j] > src_view.shape[j]:
dst_view = dst_view.narrow(j, 0, src_view.shape[j])
dst_view[i] = src_view[move_source_channels[i]]
elif "bias" in k:
for i in range(len(move_source_channels)):
if move_source_channels[i] >= 0:
dst[i] = src[move_source_channels[i]]
continue
if state_source_channels is not None and "mono.0." in k:
# Use manually specified channels to transfer from for
# first Conv2D operation on state tensor
if "weight" in k:
for i in range(len(state_source_channels)):
if state_source_channels[i] >= 0:
dst_view = dst
src_view = src
for j in range(dst_view.dim()):
if j == 1: # Don't narrow this dim, need original indexing
continue
if src_view.shape[j] > dst_view.shape[j]:
src_view = src_view.narrow(j, 0, dst_view.shape[j])
if dst_view.shape[j] > src_view.shape[j]:
dst_view = dst_view.narrow(j, 0, src_view.shape[j])
dst_view[:, i] = src_view[:, state_source_channels[i]]
elif "bias" in k:
for i in range(len(state_source_channels)):
if state_source_channels[i] >= 0:
dst[i] = src[state_source_channels[i]]
continue
delta = dst.numel() - src.numel()
if delta > 0:
params_added += delta
else:
params_removed -= delta
if dst.shape != src.shape:
print("%s shape %s -> %s" % (k, src.shape, dst.shape))
if fix_global_pooling and "resnets" in k and "0.0" in k and "weight" in k:
if src.dim() == 4 and dst.dim() == 4:
src_c = src.shape[0]
dst_c = dst.shape[0]
src_s = int(src_c * old_model_params.global_pooling)
dst_s = int(dst_c * new_model_params.global_pooling)
src_d = src_c + src_s
dst_d = dst_c + src_s
print("Moving global pooling weights from %d:%d to %d:%d" % (src_c, src_d, dst_c, dst_d))
min_c = min(src_c, dst_c)
dst[:min_c, dst_c:dst_d, :, :] = src[:min_c, src_c:src_d, :, :]
#dst.narrow(0, 0, src_c).narrow(1, dst_c, src_s).copy_(src.narrow(1, src_c, src_s))
print("Moving global pooling weights from %d:%d to %d:%d" % (src_c+src_s, src_d+src_s, dst_c+dst_s, dst_d+dst_s))
#dst.narrow(0, 0, src_c).narrow(1, dst_c+dst_s, src_s).copy_(src.narrow(1, src_c+src_s, src_s))
dst[:min_c, dst_c+dst_s:dst_d+dst_s, :, :] = src[:min_c, src_c+src_s:src_d+src_s, :, :]
src = src[:, :src_c, :, :]
dst = dst[:, :dst_c, :, :]
#src = src.narrow(1, 0, src_c)
#dst = dst.narrow(1, 0, dst_c)
while dst.dim() < src.dim():
dst = dst.unsqueeze(0)
while src.dim() < dst.dim():
src = src.unsqueeze(0)
for i in range(dst.dim()):
if src.shape[i] > dst.shape[i]:
src = src.narrow(i, 0, dst.shape[i])
if dst.shape[i] > src.shape[i]:
dst = dst.narrow(i, 0, src.shape[i])
dst.copy_(src)
print("Parameters added: %d" % params_added)
print("Parameters removed: %d" % params_removed)
print("Parameters reinitialized: %d" % params_reinitialized)
checkpoint["model_state_dict"] = s
checkpoint["model_params"] = new_model_params
checkpoint["game_params"] = new_game_params
Path(out).parent.mkdir(parents=True, exist_ok=True)
import gzip
with gzip.open(out, "wb") as f:
torch.save(checkpoint, f)
================================================
FILE: pypolygames/draw_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import time
from typing import Iterator, Tuple, Callable, Optional, List, Dict
import copy
import torch
import polygames
from .model_zoo.utils import get_game_info
from .params import GameParams, ModelParams
from .env_creation_helpers import (
create_model,
)
def draw_model(
game_params: GameParams,
model_params: ModelParams,
out: str,
):
import torchviz
m = create_model(game_params=game_params,
model_params=model_params)
info = get_game_info(game_params)
m.eval() # necessary for batch norm as it expects more than 1 ex in training
feature_size = info["feature_size"][:3]
action_size = info["action_size"][:3]
input_data = torch.zeros([1] + feature_size, device=torch.device("cpu"))
model_out = m(input_data)
dot = torchviz.make_dot((model_out["v"], model_out["pi_logit"]), params=dict(list(m.named_parameters())))
dot.format = 'png'
dot.render(out)
================================================
FILE: pypolygames/env_creation_helpers.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Optional, Iterator, List
import torch # must be loaded before tube
import tube
import mcts
import polygames
from . import model_zoo
from .params import GameParams, ModelParams
from .weight_init import WEIGHT_INIT
def sanitize_game_params(game_params: GameParams) -> None:
# eval and human modes do not support `per_thread_batchsize` != 0
# while in training, the option could have been set to > 0
# ideally this should be a simulation parameter, but it would change
# the C++ 'polygames.Game' signature
# EDIT: now it a simulation parameter, but for retro-compatibility
# we keep that function
game_params.per_thread_batchsize = 0
# Many old models don't have the game_options attribute
if not hasattr(game_params, 'game_options'):
game_params.game_options = list()
def create_game(
game_params: GameParams,
num_episode: int,
seed: int,
eval_mode: bool,
per_thread_batchsize: int = 0,
rewind: int = 0,
predict_end_state: bool = False,
predict_n_states: int = 0,
) -> polygames.Game:
# Many old models don't have the game_options attribute
if hasattr(game_params, 'game_options'):
game_options = game_params.game_options
if game_options is None:
game_options = list()
else:
game_options = list()
return polygames.Game(
game_params.game_name,
game_options,
num_episode,
seed,
eval_mode,
game_params.out_features,
game_params.turn_features,
game_params.turn_features_mc,
game_params.geometric_features,
game_params.history,
game_params.random_features,
game_params.one_feature,
per_thread_batchsize,
rewind,
predict_end_state,
predict_n_states,
) # cannot use named parameters :(
def create_model(
game_params: GameParams,
model_params: ModelParams,
resume_training: bool = False,
model_state_dict: Optional[dict] = None,
) -> torch.jit.ScriptModule:
if model_params.model_name is not None:
if model_params.model_name in model_zoo.MODELS:
model = model_zoo.MODELS[model_params.model_name](
game_params=game_params, model_params=model_params
)
else:
raise RuntimeError(
f'The model "{model_params.model_name}" has not been implemented '
f'in the "model_zoo" package'
)
else:
print("creating a generic model")
model = model_zoo.GenericModel(
game_params=game_params, model_params=model_params
)
if resume_training:
if model_state_dict is not None:
print("load state dict!")
model.load_state_dict(model_state_dict)
else:
model.apply(WEIGHT_INIT[model_params.init_method])
nb_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"total #trainable params = {nb_params}")
return model
def _set_mcts_option(
num_rollouts: int,
seed: int,
human_mode: bool = False,
time_ratio: float = 0.7,
total_time: float = 0,
sample_before_step_idx: int = 0,
randomized_rollouts: bool = False,
sampling_mcts: bool = False,
) -> mcts.MctsOption:
# TODO: put hardcoded value in conf file
mcts_option = mcts.MctsOption()
mcts_option.puct = 1.1
mcts_option.sample_before_step_idx = sample_before_step_idx
mcts_option.num_rollout_per_thread = num_rollouts
mcts_option.seed = seed
mcts_option.virtual_loss = 1
mcts_option.total_time = total_time
mcts_option.time_ratio = time_ratio
mcts_option.randomized_rollouts = randomized_rollouts
mcts_option.sampling_mcts = sampling_mcts
return mcts_option
def _create_pure_mcts_player(
game: polygames.Game, mcts_option: mcts.MctsOption, num_actor: int
) -> mcts.MctsPlayer:
"""a player that uses only mcts + random rollout, no neural net"""
player = mcts.MctsPlayer(mcts_option)
for _ in range(num_actor):
actor = polygames.Actor(
None, game.get_feat_size(), game.get_action_size(), [], 0, False, False, False, None
)
player.set_actor(actor)
return player
def _create_neural_mcts_player(
game: polygames.Game,
mcts_option: mcts.MctsOption,
num_actor: int,
actor_channel: tube.DataChannel,
model_manager: Optional[polygames.ModelManager] = None,
rnn_state_shape: List[int] = [],
rnn_seqlen: int = 0,
logit_value: bool = False,
) -> mcts.MctsPlayer:
player = mcts.MctsPlayer(mcts_option)
for _ in range(num_actor):
num_actor += 1
actor = polygames.Actor(
actor_channel,
game.get_feat_size(),
game.get_action_size(),
rnn_state_shape,
rnn_seqlen,
logit_value,
True,
True,
model_manager,
)
player.set_actor(actor)
return player
def _create_forward_player(
game: polygames.Game,
actor_channel: tube.DataChannel,
model_manager: Optional[polygames.ModelManager] = None,
rnn_state_shape: List[int] = [],
rnn_seqlen: int = 0,
logit_value: bool = False,
) -> mcts.MctsPlayer:
player = polygames.ForwardPlayer()
actor = polygames.Actor(
actor_channel,
game.get_feat_size(),
game.get_action_size(),
rnn_state_shape,
rnn_seqlen,
logit_value,
True,
True,
model_manager,
)
player.set_actor(actor)
return player
def create_player(
seed_generator: Iterator[int],
game: polygames.Game,
player: str,
num_actor: int,
num_rollouts: int,
pure_mcts: bool,
actor_channel: Optional[tube.DataChannel],
model_manager: Optional[polygames.ModelManager] = None,
human_mode: bool = False,
time_ratio: float = 0.07,
total_time: float = 0,
sample_before_step_idx: int = 0,
randomized_rollouts: bool = False,
sampling_mcts: bool = False,
rnn_state_shape: List[int] = [],
rnn_seqlen: int = 0,
logit_value: bool = False,
):
if player == "mcts":
mcts_option = _set_mcts_option(
num_rollouts=num_rollouts,
seed=next(seed_generator),
human_mode=human_mode,
time_ratio=time_ratio,
total_time=total_time,
sample_before_step_idx=sample_before_step_idx,
randomized_rollouts=randomized_rollouts,
sampling_mcts=sampling_mcts,
)
if pure_mcts:
return _create_pure_mcts_player(
game=game, mcts_option=mcts_option, num_actor=num_actor
)
else:
return _create_neural_mcts_player(
game=game,
mcts_option=mcts_option,
num_actor=num_actor,
actor_channel=actor_channel,
model_manager=model_manager,
rnn_state_shape=rnn_state_shape,
rnn_seqlen=rnn_seqlen,
logit_value=logit_value
)
elif player == "forward":
return _create_forward_player(
game=game,
actor_channel=actor_channel,
model_manager=model_manager,
rnn_state_shape=rnn_state_shape,
rnn_seqlen=rnn_seqlen,
logit_value=logit_value
)
else:
raise RuntimeError("Unknown player " + player)
================================================
FILE: pypolygames/evaluation.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import sys
import time
from concurrent.futures import ThreadPoolExecutor
from typing import Iterator, Tuple, List, Callable, Optional, Dict
import torch
import tube
from pytube.data_channel_manager import DataChannelManager
from .params import GameParams, EvalParams, ExecutionParams
from . import utils
from .env_creation_helpers import (
sanitize_game_params,
create_model,
create_game,
create_player,
)
#######################################################################################
# PLOTTER CREATION
#######################################################################################
def create_plotter(eval_params: EvalParams) -> utils.Plotter:
checkpoint_dir = eval_params.checkpoint_dir
if checkpoint_dir[-1] == "/":
checkpoint_dir = checkpoint_dir[:-1]
plot_env = os.path.basename(checkpoint_dir)
return utils.Plotter(
plot_enabled=eval_params.plot_enabled,
env=plot_env,
server=eval_params.plot_server,
port=eval_params.plot_port,
)
#######################################################################################
# CHECKPOINT ITERATOR CREATION
#######################################################################################
def create_checkpoint_iter(eval_params: EvalParams, only_last: bool = False):
if eval_params.checkpoint_dir is not None:
return utils.gen_checkpoints(
checkpoint_dir=eval_params.checkpoint_dir,
real_time=eval_params.real_time and not only_last,
only_last=only_last,
)
else:
return [utils.load_checkpoint(eval_params.checkpoint)]
#######################################################################################
# OPPONENT MODEL AND DEVICE CREATION
#######################################################################################
def create_models_and_devices_opponent(
eval_params: EvalParams
) -> Tuple[List[torch.jit.ScriptModule], List[torch.device], GameParams]:
devices_opponent = [
torch.device(device_opponent) for device_opponent in eval_params.device_opponent
]
checkpoint_opponent = utils.load_checkpoint(eval_params.checkpoint_opponent)
model_state_dict_opponent = checkpoint_opponent["model_state_dict"]
game_params_opponent = checkpoint_opponent["game_params"]
sanitize_game_params(game_params_opponent)
model_params_opponent = checkpoint_opponent["model_params"]
models_opponent = []
for device_opponent in devices_opponent:
model_opponent = create_model(
game_params=game_params_opponent,
model_params=model_params_opponent,
resume_training=False,
).to(device_opponent)
remove = []
for k, v in model_state_dict_opponent.items():
if "training" in k:
remove.append(k)
for k in remove:
model_state_dict_opponent.pop(k)
model_opponent.load_state_dict(model_state_dict_opponent)
model_opponent.eval()
models_opponent.append(model_opponent)
return models_opponent, devices_opponent, game_params_opponent
#######################################################################################
# EVALUATION ENVIRONMENT CREATION
#######################################################################################
def create_evaluation_environment(
seed_generator: Iterator[int],
game_params: GameParams,
eval_params: EvalParams,
current_batch_size: int = None,
pure_mcts_eval: bool = False,
pure_mcts_opponent: bool = True,
num_evaluated_games: int = 0
) -> Tuple[
tube.Context,
Optional[tube.DataChannel],
Optional[tube.DataChannel],
Callable[[], List[int]],
]:
num_game = eval_params.num_game_eval
num_actor_eval = eval_params.num_actor_eval
num_rollouts_eval = eval_params.num_rollouts_eval
num_actor_opponent = eval_params.num_actor_opponent
num_rollouts_opponent = eval_params.num_rollouts_opponent
first_hand = []
second_hand = []
games = []
context = tube.Context()
actor_channel_eval = (
None
if pure_mcts_eval
else tube.DataChannel("act_eval", num_game * num_actor_eval, 1)
)
actor_channel_opponent = (
None
if pure_mcts_opponent
else tube.DataChannel("act_opponent", num_game * num_actor_opponent, 1)
)
for game_no in range(current_batch_size if current_batch_size else num_game):
game = create_game(
game_params, num_episode=1, seed=next(seed_generator), eval_mode=True
)
player = create_player(
seed_generator=seed_generator,
game=game,
player="mcts",
num_actor=num_actor_eval,
num_rollouts=num_rollouts_eval,
pure_mcts=pure_mcts_eval,
actor_channel=actor_channel_eval,
model_manager=None,
human_mode=False,
sample_before_step_idx=8,
randomized_rollouts=False,
sampling_mcts=False,
)
if game.is_one_player_game():
game.add_eval_player(player)
first_hand.append(game)
else:
opponent = create_player(
seed_generator=seed_generator,
game=game,
player="mcts",
num_actor=num_actor_opponent,
num_rollouts=num_rollouts_opponent,
pure_mcts=pure_mcts_opponent,
actor_channel=actor_channel_opponent,
model_manager=None,
human_mode=False,
sample_before_step_idx=8,
randomized_rollouts=False,
sampling_mcts=False,
)
game_id = num_evaluated_games + game_no
if player_moves_first(game_id, num_game):
game.add_eval_player(player)
game.add_eval_player(opponent)
first_hand.append(game)
else:
game.add_eval_player(opponent)
game.add_eval_player(player)
second_hand.append(game)
context.push_env_thread(game)
games.append(game)
def get_eval_reward():
nonlocal first_hand, second_hand
reward = []
for hand in first_hand:
reward.append(hand.get_result()[0])
for hand in second_hand:
reward.append(hand.get_result()[1])
return reward
return context, actor_channel_eval, actor_channel_opponent, get_eval_reward
def player_moves_first(game_id, num_games_eval):
return game_id < num_games_eval // 2
#######################################################################################
# EVALUATION
#######################################################################################
def _forward_pass_on_device(
device: torch.device, model: torch.jit.ScriptModule, batch_s: torch.Tensor
) -> Dict[str, torch.Tensor]:
batch_s = utils.to_device(batch_s, device)
with torch.no_grad():
reply = model(batch_s)
return reply
def _play_game_neural_mcts_against_pure_mcts_opponent(
context: tube.Context,
actor_channel_eval: tube.DataChannel,
devices_eval: List[torch.device],
models_eval: List[torch.jit.ScriptModule],
) -> None:
nb_devices_eval = len(devices_eval)
context.start()
dcm = DataChannelManager([actor_channel_eval])
while not context.terminated():
batch = dcm.get_input(max_timeout_s=1)
if len(batch) == 0:
continue
assert len(batch) == 1 # only one channel
# split in as many part as there are devices
batches_eval_s = torch.chunk(
batch[actor_channel_eval.name]["s"], nb_devices_eval, dim=0
)
futures = []
reply_eval = {"v": None, "pi_logit": None}
# multithread
with ThreadPoolExecutor(max_workers=nb_devices_eval) as executor:
for device, model, batch_s in zip(
devices_eval, models_eval, batches_eval_s
):
futures.append(
executor.submit(_forward_pass_on_device, device, model, batch_s)
)
results = [future.result() for future in futures]
reply_eval["v"] = torch.cat([result["v"] for result in results], dim=0)
reply_eval["pi_logit"] = torch.cat([result["pi_logit"] for result in results], dim=0)
dcm.set_reply(actor_channel_eval.name, reply_eval)
dcm.terminate()
def _play_game_neural_mcts_against_neural_mcts_opponent(
context: tube.Context,
actor_channel_eval: tube.DataChannel,
actor_channel_opponent: tube.DataChannel,
devices_eval: List[torch.device],
models_eval: List[torch.jit.ScriptModule],
devices_opponent: List[torch.device],
models_opponent: List[torch.jit.ScriptModule],
) -> None:
nb_devices_eval = len(devices_eval)
nb_devices_opponent = len(devices_opponent)
context.start()
dcm = DataChannelManager([actor_channel_eval, actor_channel_opponent])
while not context.terminated():
batch = dcm.get_input(max_timeout_s=1)
if len(batch) == 0:
continue
assert len(batch) <= 2 # up to two channels
if actor_channel_eval.name in batch:
# split in as many part as there are devices
batches_eval_s = torch.chunk(
batch[actor_channel_eval.name]["s"], nb_devices_eval, dim=0
)
futures = []
reply_eval = {"v": None, "pi_logit": None}
# multithread
with ThreadPoolExecutor(max_workers=nb_devices_eval) as executor:
for device, model, batch_s in zip(
devices_eval, models_eval, batches_eval_s
):
futures.append(
executor.submit(_forward_pass_on_device, device, model, batch_s)
)
results = [future.result() for future in futures]
reply_eval["v"] = torch.cat([result["v"] for result in results], dim=0)
reply_eval["pi_logit"] = torch.cat(
[result["pi_logit"] for result in results], dim=0
)
dcm.set_reply(actor_channel_eval.name, reply_eval)
if actor_channel_opponent.name in batch:
# split in as many part as there are devices
batches_opponent_s = torch.chunk(
batch[actor_channel_opponent.name]["s"], nb_devices_opponent, dim=0
)
futures = []
reply_opponent = {"v": None, "pi_logit": None}
# multithread
with ThreadPoolExecutor(max_workers=nb_devices_opponent) as executor:
for device, model, batch_s in zip(
devices_opponent, models_opponent, batches_opponent_s
):
futures.append(
executor.submit(_forward_pass_on_device, device, model, batch_s)
)
results = [future.result() for future in futures]
reply_opponent["v"] = torch.cat(
[result["v"] for result in results], dim=0
)
reply_opponent["pi_logit"] = torch.cat(
[result["pi_logit"] for result in results], dim=0
)
dcm.set_reply(actor_channel_opponent.name, reply_opponent)
dcm.terminate()
def evaluate_on_checkpoint(
game_params: GameParams,
eval_params: EvalParams,
context: tube.Context,
actor_channel_eval: Optional[tube.DataChannel],
actor_channel_opponent: Optional[tube.DataChannel],
get_eval_reward: Callable[[], List[int]],
devices_eval: Optional[List[torch.device]],
models_eval: Optional[List[torch.jit.ScriptModule]],
pure_mcts_eval: bool,
devices_opponent: Optional[List[torch.device]],
models_opponent: Optional[List[torch.jit.ScriptModule]],
pure_mcts_opponent: bool,
) -> utils.Result:
if eval_params.eval_verbosity:
print(f"Playing {eval_params.num_game_eval} games of {game_params.game_name}:")
print(
f"- {'pure MCTS' if pure_mcts_eval else type(models_eval[0]).__name__} "
f"player uses "
f"{eval_params.num_rollouts_eval} rollouts per actor "
f"with {eval_params.num_actor_eval} "
f"actor{'s' if eval_params.num_actor_eval > 1 else ''}"
)
print(
f"- {'pure MCTS' if pure_mcts_opponent else type(models_opponent[0]).__name__} "
f"opponent uses "
f"{eval_params.num_rollouts_opponent} rollouts per actor "
f"with {eval_params.num_actor_opponent} "
f"actor{'s' if eval_params.num_actor_opponent > 1 else ''}"
)
if pure_mcts_eval:
pass # not implemented
else:
if pure_mcts_opponent:
_play_game_neural_mcts_against_pure_mcts_opponent(
context=context,
actor_channel_eval=actor_channel_eval,
devices_eval=devices_eval,
models_eval=models_eval,
)
else:
_play_game_neural_mcts_against_neural_mcts_opponent(
context=context,
actor_channel_eval=actor_channel_eval,
actor_channel_opponent=actor_channel_opponent,
devices_eval=devices_eval,
models_eval=models_eval,
devices_opponent=devices_opponent,
models_opponent=models_opponent,
)
result = utils.Result(get_eval_reward())
if eval_params.eval_verbosity >= 2:
print("@@@eval: %s" % result.log())
return result
#######################################################################################
# OVERALL EVALUATION WORKFLOW
#######################################################################################
def run_evaluation(eval_params: EvalParams, execution_params: ExecutionParams, only_last: bool = False) -> None:
start_time = time.time()
logger_dir = eval_params.checkpoint_dir
if eval_params.checkpoint_dir is None:
logger_dir = os.path.dirname(eval_params.checkpoint)
logger_path = os.path.join(logger_dir, "eval.log")
sys.stdout = utils.Logger(logger_path)
print("#" * 70)
print("#" + "EVALUATION".center(68) + "#")
print("#" * 70)
# evaluation is done on a NN-powered MCTS
pure_mcts_eval = False
print("setting-up pseudo-random generator...")
seed_generator = utils.generate_random_seeds(seed=eval_params.seed_eval)
if eval_params.plot_enabled:
print("creating plotter...")
plotter = create_plotter(eval_params=eval_params)
print("finding checkpoints...")
checkpoint_iter = create_checkpoint_iter(
eval_params=eval_params, only_last=only_last
)
models_opponent = []
pure_mcts_opponent = True
devices_opponent = None
game_params_opponent = None
if eval_params.checkpoint_opponent is not None:
print("creating opponent model(s) and device(s)...")
pure_mcts_opponent = False
(
models_opponent,
devices_opponent,
game_params_opponent,
) = create_models_and_devices_opponent(eval_params=eval_params)
results = []
first_checkpoint = False
game_params = None
for checkpoint in checkpoint_iter:
epoch = checkpoint.get("epoch", 0) # 0 when checkpoint_dir is None
model_state_dict_eval = checkpoint["model_state_dict"]
model_params_eval = checkpoint["model_params"]
if game_params is None:
game_params = checkpoint["game_params"]
sanitize_game_params(game_params)
# check that game_params are consistent between the model_eval and
# the model_opponent
if game_params_opponent is not None and game_params != game_params_opponent:
raise ValueError(
"The game parameters between the model to be tested"
"and the opponent model are different"
)
# check that game_params are consistent from one epoch to the other
checkpoint_game_params = checkpoint["game_params"]
sanitize_game_params(checkpoint_game_params)
if game_params != checkpoint_game_params:
raise ValueError(f"The game parameters have changed at checkpoint #{epoch}")
if not first_checkpoint:
print("creating model(s) and device(s)...")
devices_eval = [
torch.device(device_eval) for device_eval in eval_params.device_eval
]
models_eval = []
for device_eval in devices_eval:
models_eval.append(
create_model(
game_params=game_params,
model_params=model_params_eval,
resume_training=False,
).to(device_eval)
)
first_checkpoint = True
print("updating model(s)...")
for model_eval in models_eval:
model_eval.load_state_dict(model_state_dict_eval)
model_eval.eval()
num_evaluated_games = 0
rewards = []
eval_batch_size = eval_params.num_parallel_games_eval if eval_params.num_parallel_games_eval else eval_params.num_game_eval
print("evaluating {} games with batches of size {}".format(eval_params.num_game_eval, eval_batch_size))
while num_evaluated_games < eval_params.num_game_eval:
if eval_params.eval_verbosity:
print("creating evaluation environment...")
current_batch_size = min(eval_batch_size, eval_params.num_game_eval - num_evaluated_games)
(
context,
actor_channel_eval,
actor_channel_opponent,
get_eval_reward,
) = create_evaluation_environment(
seed_generator=seed_generator,
game_params=game_params,
eval_params=eval_params,
current_batch_size=current_batch_size,
pure_mcts_eval=pure_mcts_eval,
pure_mcts_opponent=pure_mcts_opponent,
num_evaluated_games=num_evaluated_games,
)
if eval_params.eval_verbosity:
print("evaluating...")
partial_result = evaluate_on_checkpoint(
game_params=game_params,
eval_params=eval_params,
context=context,
actor_channel_eval=actor_channel_eval,
actor_channel_opponent=actor_channel_opponent,
get_eval_reward=get_eval_reward,
devices_eval=devices_eval,
models_eval=models_eval,
pure_mcts_eval=pure_mcts_eval,
devices_opponent=devices_opponent,
models_opponent=models_opponent,
pure_mcts_opponent=pure_mcts_opponent,
)
num_evaluated_games += current_batch_size
rewards += partial_result.reward
elapsed_time = time.time() - start_time
print(f"Evaluated on {num_evaluated_games} games in : {elapsed_time} s")
result = utils.Result(rewards)
print("@@@eval: %s" % result.log())
results.append((epoch, result))
if eval_params.plot_enabled:
print("plotting...")
plotter.plot_results(results)
plotter.save()
elapsed_time = time.time() - start_time
print(f"total time: {elapsed_time} s")
================================================
FILE: pypolygames/human.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import time
from concurrent.futures import ThreadPoolExecutor
from typing import Iterator, Tuple, Callable, Optional, List, Dict
import torch
import tube
import polygames
from pytube.data_channel_manager import DataChannelManager
from . import utils
from .params import GameParams, ModelParams, SimulationParams, ExecutionParams
from .env_creation_helpers import (
sanitize_game_params,
create_model,
create_game,
create_player,
)
#######################################################################################
# HUMAN-PLAYED ENVIRONMENT CREATION
#######################################################################################
def create_human_environment(
seed_generator: Iterator[int],
game_params: GameParams,
simulation_params: SimulationParams,
execution_params: ExecutionParams,
pure_mcts: bool,
model
) -> Tuple[tube.Context, Optional[tube.DataChannel], Callable[[], int]]:
human_first = execution_params.human_first
time_ratio = execution_params.time_ratio
total_time = execution_params.total_time
context = tube.Context()
actor_channel = (
None if pure_mcts else tube.DataChannel("act", simulation_params.num_actor, 1)
)
rnn_state_shape = []
if model is not None and hasattr(model, "rnn_cells") and model.rnn_cells > 0:
rnn_state_shape = [model.rnn_cells, model.rnn_channels]
rnn_state_size = 0
if len(rnn_state_shape) >= 2:
rnn_state_size = rnn_state_shape[0] * rnn_state_shape[1]
logit_value = getattr(model, "logit_value", False)
game = create_game(
game_params,
num_episode=1,
seed=next(seed_generator),
eval_mode=True,
per_thread_batchsize=0,
rewind=simulation_params.rewind,
predict_end_state=game_params.predict_end_state,
predict_n_states=game_params.predict_n_states,
)
player = create_player(
seed_generator=seed_generator,
game=game,
player="mcts",
num_actor=simulation_params.num_actor,
num_rollouts=simulation_params.num_rollouts,
pure_mcts=pure_mcts,
actor_channel=actor_channel,
model_manager=None,
human_mode=True,
total_time=total_time,
time_ratio=time_ratio,
sample_before_step_idx=80,
randomized_rollouts=False,
sampling_mcts=False,
rnn_state_shape=rnn_state_shape,
rnn_seqlen=execution_params.rnn_seqlen,
logit_value=logit_value,
)
human_player = polygames.HumanPlayer()
if game.is_one_player_game():
game.add_human_player(human_player)
else:
if human_first:
game.add_human_player(human_player)
game.add_eval_player(player)
else:
game.add_eval_player(player)
game.add_human_player(human_player)
context.push_env_thread(game)
def get_result_for_human_player():
nonlocal game, human_first
return game.get_result()[not human_first]
return context, actor_channel, get_result_for_human_player
def create_tp_environment(
seed_generator: Iterator[int],
game_params: GameParams,
simulation_params: SimulationParams,
execution_params: ExecutionParams,
pure_mcts: bool,
) -> Tuple[tube.Context, Optional[tube.DataChannel], Callable[[], int]]:
human_first = execution_params.human_first
time_ratio = execution_params.time_ratio
total_time = execution_params.total_time
context = tube.Context()
actor_channel = (
None if pure_mcts else tube.DataChannel("act", simulation_params.num_actor, 1)
)
game = create_game(
game_params,
num_episode=1,
seed=next(seed_generator),
eval_mode=True,
per_thread_batchsize=0,
)
player = create_player(
seed_generator=seed_generator,
game=game,
num_actor=simulation_params.num_actor,
num_rollouts=simulation_params.num_rollouts,
pure_mcts=pure_mcts,
actor_channel=actor_channel,
model_manager=None,
human_mode=True,
total_time=total_time,
time_ratio=time_ratio,
)
tp_player = polygames.TPPlayer()
if game.is_one_player_game():
game.add_tp_player(tp_player)
else:
if human_first:
game.add_tp_player(tp_player)
game.add_eval_player(player)
else:
game.add_eval_player(player)
game.add_tp_player(tp_player)
context.push_env_thread(game)
def get_result_for_tp_player():
nonlocal game, human_first
return game.get_result()[not human_first]
return context, actor_channel, get_result_for_tp_player
#######################################################################################
# HUMAN-PLAYED GAME
#######################################################################################
def _forward_pass_on_device(
device: torch.device, model: torch.jit.ScriptModule, batch_s: torch.Tensor, batch_rnn_state: torch.Tensor = None
) -> Dict[str, torch.Tensor]:
batch_s = utils.to_device(batch_s, device)
if batch_rnn_state is not None:
batch_rnn_state = utils.to_device(batch_rnn_state, device)
with torch.no_grad():
reply = model(batch_s, batch_rnn_state)
else:
with torch.no_grad():
reply = model(batch_s)
return reply
def _play_game_against_mcts(context: tube.Context) -> None:
context.start()
while not context.terminated():
time.sleep(1)
def _play_game_against_neural_mcts(
devices: List[torch.device],
models: List[torch.jit.ScriptModule],
context: tube.Context,
actor_channel: tube.DataChannel,
) -> None:
nb_devices = len(devices)
context.start()
dcm = DataChannelManager([actor_channel])
# multithread
with ThreadPoolExecutor(max_workers=nb_devices) as executor:
while not context.terminated():
batch = dcm.get_input(max_timeout_s=1)
if len(batch) == 0:
continue
assert len(batch) == 1
# split in as many part as there are devices
batches_s = torch.chunk(
batch[actor_channel.name]["s"], nb_devices, dim=0
)
has_rnn = "rnn_state" in batch[actor_channel.name]
if has_rnn:
batches_rnn_state = torch.chunk(
batch[actor_channel.name]["rnn_state"], nb_devices, dim=0
)
futures = []
reply_eval = {"v": None, "pi_logit": None}
if has_rnn:
for device, model, batch_s, batch_rnn_state in zip(
devices, models, batches_s, batches_rnn_state
):
futures.append(
executor.submit(_forward_pass_on_device, device, model, batch_s, batch_rnn_state)
)
results = [future.result() for future in futures]
reply_eval["v"] = torch.cat([result["v"] for result in results], dim=0)
reply_eval["pi_logit"] = torch.cat([result["pi_logit"] for result in results], dim=0)
reply_eval["rnn_state_out"] = torch.cat([result["rnn_state"] for result in results], dim=0)
else:
for device, model, batch_s in zip(
devices, models, batches_s
):
futures.append(
executor.submit(_forward_pass_on_device, device, model, batch_s)
)
results = [future.result() for future in futures]
reply_eval["v"] = torch.cat([result["v"] for result in results], dim=0)
reply_eval["pi_logit"] = torch.cat([result["pi_logit"] for result in results], dim=0)
dcm.set_reply(actor_channel.name, reply_eval)
dcm.terminate()
def play_game(
pure_mcts: bool,
devices: Optional[List[torch.device]],
models: Optional[List[torch.jit.ScriptModule]],
context: tube.Context,
actor_channel: Optional[tube.DataChannel],
get_result_for_human_player: Callable[[], int],
) -> int:
if pure_mcts:
_play_game_against_mcts(context)
else:
_play_game_against_neural_mcts(
devices=devices, models=models, context=context, actor_channel=actor_channel
)
print("game over")
return get_result_for_human_player()
def play_tp_game( #FIXME TODO not sure this helps
pure_mcts: bool,
devices: Optional[List[torch.device]],
models: Optional[List[torch.jit.ScriptModule]],
context: tube.Context,
actor_channel: Optional[tube.DataChannel],
get_result_for_human_player: Callable[[], int],
) -> int:
if pure_mcts:
_play_game_against_mcts(context)
else:
_play_game_against_neural_mcts(
devices=devices, models=models, context=context, actor_channel=actor_channel
)
print("#game over")
return get_result_for_human_player()
#######################################################################################
# OVERALL HUMAN-PLAYED GAME WORKFLOW
#######################################################################################
def run_human_played_game(
game_params: GameParams,
model_params: ModelParams,
simulation_params: SimulationParams,
execution_params: ExecutionParams,
):
print("#" * 70)
print("#" + "HUMAN-PLAYED GAME".center(68) + "#")
print("#" * 70)
print("setting-up pseudo-random generator...")
seed_generator = utils.generate_random_seeds(seed=execution_params.seed)
devices, models = None, None
if not model_params.pure_mcts:
print("loading pretrained model from checkpoint...")
checkpoint = utils.load_checkpoint(checkpoint_path=model_params.init_checkpoint)
game_params = checkpoint["game_params"]
sanitize_game_params(game_params)
model_params = checkpoint["model_params"]
model_state_dict = checkpoint["model_state_dict"]
del checkpoint
print("creating model(s) and device(s)...")
models = []
devices = [torch.device(device) for device in execution_params.devices]
for device in devices:
model = create_model(game_params=game_params, model_params=model_params).to(
device
)
print("updating model...")
model.load_state_dict(model_state_dict)
model.eval()
models.append(model)
print("creating human-played environment")
context, actor_channel, get_result_for_human_player = create_human_environment(
seed_generator=seed_generator,
game_params=game_params,
simulation_params=simulation_params,
execution_params=execution_params,
pure_mcts=model_params.pure_mcts,
model=model
)
print("playing against a human player...")
human_score = play_game(
pure_mcts=model_params.pure_mcts,
devices=devices,
models=models,
context=context,
actor_channel=actor_channel,
get_result_for_human_player=get_result_for_human_player,
)
print(f"result for the human human_player: {human_score}")
def run_tp_played_game(
game_params: GameParams,
model_params: ModelParams,
simulation_params: SimulationParams,
execution_params: ExecutionParams,
):
print("#" * 70)
print("#" + "HUMAN-PLAYED GAME".center(68) + "#")
print("#" * 70)
print("#setting-up pseudo-random generator...")
seed_generator = utils.generate_random_seeds(seed=execution_params.seed)
devices, models = None, None
if not model_params.pure_mcts:
print("#loading pretrained model from checkpoint...")
checkpoint = utils.load_checkpoint(checkpoint_path=model_params.init_checkpoint)
game_params = checkpoint["game_params"]
sanitize_game_params(game_params)
model_params = checkpoint["model_params"]
model_state_dict = checkpoint["model_state_dict"]
del checkpoint
print("#creating model(s) and device(s)...")
models = []
devices = [torch.device(device) for device in execution_params.device]
for device in devices:
model = create_model(game_params=game_params, model_params=model_params).to(
device
)
print("#updating model...")
model.load_state_dict(model_state_dict)
model.eval()
models.append(model)
print("#creating human-played environment")
context, actor_channel, get_result_for_human_player = create_tp_environment(
seed_generator=seed_generator,
game_params=game_params,
simulation_params=simulation_params,
execution_params=execution_params,
pure_mcts=model_params.pure_mcts,
)
print("#playing against a tp player...")
human_score = play_tp_game(
pure_mcts=model_params.pure_mcts,
devices=devices,
models=models,
context=context,
actor_channel=actor_channel,
get_result_for_human_player=get_result_for_human_player,
)
print(f"#result for the TP_player: {human_score}")
================================================
FILE: pypolygames/model_zoo/__init__.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from .generic_model import GenericModel
from .amazons_model import AmazonsModel
from .nano_fc_logit_model import NanoFCLogitModel
from .nano_conv_logit_model import NanoConvLogitModel
from .deep_conv_fc_logit_model import DeepConvFCLogitModel
from .deep_conv_conv_logit_model import DeepConvConvLogitModel
from .res_conv_fc_logit_model import ResConvFCLogitModel
from .res_conv_conv_logit_model import ResConvConvLogitModel
from .res_conv_conv_logit_pool_model import ResConvConvLogitPoolModel
from .res_conv_conv_logit_pool_model_v2 import ResConvConvLogitPoolModelV2
from .u_conv_fc_logit_model import UConvFCLogitModel
from .u_conv_conv_logit_model import UConvConvLogitModel
from .connect4_benchmark_model import Connect4BenchModel
from .utils import MODELS # directory where models are registered
================================================
FILE: pypolygames/model_zoo/amazons_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class AmazonsModel(torch.jit.ScriptModule):
__constants__ = ["c_prime", "h_prime", "w_prime"]
DEFAULT_FCSIZE = 1024
DEFAULT_NNSIZE = 4
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
default_game_name = "GameOfTheAmazons"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
# fc size
if model_params.fcsize is None:
model_params.fcsize = self.DEFAULT_FCSIZE
fcsize = model_params.fcsize
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
self.model_params = model_params
self.net1 = nn.Conv2d(
c, int(nnsize * c), nnks, stride=stride, padding=padding, dilation=dilation
)
self.net2 = nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
)
self.net3 = nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
)
self.net4 = nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
)
self.v1 = nn.Linear(int(nnsize * c) * h * w, fcsize)
self.v2 = nn.Linear(fcsize, fcsize)
self.v3 = nn.Linear(fcsize, 1)
self.pi1 = nn.Linear(int(nnsize * c) * h * w, fcsize)
self.pi2 = nn.Linear(fcsize, fcsize)
self.pi3 = nn.Linear(fcsize, c_prime + h_prime + w_prime)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime
bs = x.shape[0]
h1 = nn.functional.relu(self.net1(x))
h2 = nn.functional.relu(self.net2(h1)) + h1
h3 = nn.functional.relu(self.net3(h2)) + h2
h4 = nn.functional.relu(self.net4(h3)) + h3
v = nn.functional.relu(self.v1(h4.flatten(1)))
v = nn.functional.relu(self.v2(v))
v = torch.tanh(self.v3(v))
pi_logit = nn.functional.relu(self.pi1(h4.flatten(1)))
pi_logit = nn.functional.relu(self.pi2(pi_logit))
pi_logit = nn.functional.relu(self.pi3(pi_logit))
if return_logit:
v1 = pi_logit[:, :c_prime].reshape(-1, c_prime, 1, 1)
v2 = pi_logit[:, c_prime : c_prime + h_prime].reshape(-1, 1, h_prime, 1)
v3 = pi_logit[:, c_prime + h_prime :].reshape(-1, 1, 1, w_prime)
# This representation is not sparse, that's a temporary hack
# for testing the idea of a cartesian product.
pi_logit = v1 + v2 + v3
return v, pi_logit
# TODO(oteytaud): remove duplicate reshaping.
v1 = nn.functional.softmax(pi_logit[:, :c_prime].reshape(-1, c_prime, 1, 1), 1)
v2 = nn.functional.softmax(
pi_logit[:, c_prime : c_prime + h_prime].reshape(-1, 1, h_prime, 1), 2
)
v3 = nn.functional.softmax(
pi_logit[:, c_prime + h_prime :].reshape(-1, 1, 1, w_prime), 3
)
pi = v1 * v2 * v3
# pi = nn.functional.softmax(pi.view(pi.shape[0], -1), 1).reshape(pi.shape)
# This representation is not sparse, that's a temporary hack
# for testing the idea of a cartesian product.
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
def loss(
self,
model,
x: torch.Tensor,
v: torch.Tensor,
pi: torch.Tensor,
pi_mask: torch.Tensor,
stat: utils.MultiCounter
) -> float:
# print(x.size())
# print(x[0])
# print(v)
# print(pi.size())
batchsize = pi.shape[0]
# pi = pi.view(batchsize, -1)
pred_v, pred_logit = self._forward(x, True)
utils.assert_eq(v.size(), pred_v.size())
utils.assert_eq(pred_logit.size(), pi.size())
utils.assert_eq(pred_logit.dim(), 4)
pred_logit = pred_logit * pi_mask.view(pred_logit.shape)
# pred_logit = pred_logit.view(batchsize, -1)
v_err = 0.5 * (v - pred_v).pow(2).squeeze(1)
s = pred_logit.shape
bs = x.shape[0]
pred_log_pi = nn.functional.log_softmax(pred_logit.flatten(1), 1).reshape(s)
# pred_log_pi = nn.functional.log_softmax(pred_logit, 1)
pi_err = -(pred_log_pi * pi).reshape(bs, -1).sum(1)
# why would these quantities be equal ?
utils.assert_eq(v_err.size(), pi_err.size())
err = v_err + pi_err
stat["v_err"].feed(v_err.detach().mean().item())
stat["pi_err"].feed(pi_err.detach().mean().item())
return err.mean()
================================================
FILE: pypolygames/model_zoo/connect4_benchmark_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
from . import utils as zutils
from ..params import GameParams, ModelParams
# import utils
@zutils.register_model
class Connect4BenchModel(torch.jit.ScriptModule):
def __init__(self, game_params: GameParams, model_params: ModelParams):
# def __init__(self):
super().__init__()
self.fc1 = nn.Linear(6 * 7 * 2, 200)
self.fc2 = nn.Linear(200, 200)
self.fc3 = nn.Linear(200, 200)
self.fc_pi = nn.Linear(200, 7)
self.fc_val = nn.Linear(200, 1)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
x = x[:, :2, :, :]
# print(x.size())
x = x.view(-1, 84)
h = nn.functional.relu(self.fc1(x))
h = nn.functional.relu(self.fc2(h))
h = nn.functional.relu(self.fc3(h))
v = self.fc_val(h)
pi_logit = self.fc_pi(h)
if return_logit:
return v, pi_logit
pi = nn.functional.softmax(pi_logit, 1)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, 7, 1, 1)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/deep_conv_conv_logit_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class DeepConvConvLogitModel(torch.jit.ScriptModule):
__constants__ = ["c_prime", "h_prime", "w_prime", "mono", "conv_nets"]
DEFAULT_NB_NETS = 13
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_POOLING = False
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Hex13"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
if h_prime != h or w_prime != w:
raise RuntimeError(
f'The game "{self.game_name}" is not eligible to a conv-computed logit '
f'model such as "{self.__class__.__name__}" - try with '
f'"{self.__class__.__name__.replace("ConvLogit", "FCLogit")}" instead'
)
# nb identical hidden layers (first layer excepted)
if model_params.nb_nets is None:
model_params.nb_nets = self.DEFAULT_NB_NETS
nb_nets = model_params.nb_nets
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# pooling
if model_params.pooling is None:
model_params.pooling = self.DEFAULT_POOLING
pooling = model_params.pooling
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
mono = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
conv_nets = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
for _ in range(nb_nets)
]
if pooling:
for i in range(nb_nets):
conv_nets[i] = nn.Sequential(
conv_nets[i],
nn.MaxPool2d(
kernel_size=nnks,
padding=padding,
stride=stride,
dilation=dilation,
),
)
if bn or bn_affine:
mono.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
for i in range(nb_nets):
conv_nets[i] = nn.Sequential(
conv_nets[i],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine
),
)
self.mono = nn.Sequential(*mono)
self.conv_nets = nn.ModuleList(conv_nets)
self.v = nn.Linear(int(nnsize * c) * h * w, 1)
self.pi_logit = nn.Conv2d(
int(nnsize * c), c_prime, nnks, stride=stride, padding=padding, dilation=dilation
)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
bs = x.shape[0]
h = F.relu(self.mono(x))
for conv_net in self.conv_nets:
h = F.relu(conv_net(h))
v = torch.tanh(self.v(h.flatten(1)))
pi_logit = self.pi_logit(h).flatten(1)
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit.flatten(1), 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/deep_conv_fc_logit_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class DeepConvFCLogitModel(torch.jit.ScriptModule):
__constants__ = ["c_prime", "h_prime", "w_prime", "mono", "conv_nets"]
DEFAULT_NB_NETS = 13
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_POOLING = False
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Connect4"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
# nb identical hidden layers (first layer excepted)
if model_params.nb_nets is None:
model_params.nb_nets = self.DEFAULT_NB_NETS
nb_nets = model_params.nb_nets
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# pooling
if model_params.pooling is None:
model_params.pooling = self.DEFAULT_POOLING
pooling = model_params.pooling
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
mono = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
conv_nets = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
for _ in range(nb_nets)
]
if pooling:
for i in range(nb_nets):
conv_nets[i] = nn.Sequential(
conv_nets[i],
nn.MaxPool2d(
kernel_size=nnks,
padding=padding,
stride=stride,
dilation=dilation,
),
)
if bn or bn_affine:
mono.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
for i in range(nb_nets):
conv_nets[i] = nn.Sequential(
conv_nets[i],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine
),
)
self.mono = nn.Sequential(*mono)
self.conv_nets = nn.ModuleList(conv_nets)
self.v = nn.Linear(int(nnsize * c) * h * w, 1)
self.pi_logit = nn.Linear(int(nnsize * c) * h * w, c_prime * h_prime * w_prime)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
bs = x.shape[0]
h = F.relu(self.mono(x))
for conv_net in self.conv_nets:
h = F.relu(conv_net(h))
v = torch.tanh(self.v(h.flatten(1)))
pi_logit = self.pi_logit(h.flatten(1))
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit.flatten(1), 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/generic_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class GenericModel(torch.jit.ScriptModule):
__constants__ = [
"c_prime",
"h_prime",
"w_prime",
"net1",
"net2",
"net3",
"net4",
"v1",
"v2",
"pi1",
"pi2",
]
DEFAULT_FCSIZE = 1024
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Connect4"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
# fc size
if model_params.fcsize is None:
model_params.fcsize = self.DEFAULT_FCSIZE
fcsize = model_params.fcsize
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
net1 = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
net2 = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
net3 = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
net4 = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
v1 = [nn.Linear(int(nnsize * c) * h * w, fcsize)]
v2 = [nn.Linear(fcsize, fcsize)]
pi1 = [nn.Linear(int(nnsize * c) * h * w, fcsize)]
pi2 = [nn.Linear(fcsize, fcsize)]
if bn or bn_affine:
net1.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
net2.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
net3.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
net4.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
v1.append(
nn.BatchNorm1d(fcsize, track_running_stats=True, affine=bn_affine)
)
v2.append(
nn.BatchNorm1d(fcsize, track_running_stats=True, affine=bn_affine)
)
pi1.append(
nn.BatchNorm1d(fcsize, track_running_stats=True, affine=bn_affine)
)
pi2.append(
nn.BatchNorm1d(fcsize, track_running_stats=True, affine=bn_affine)
)
self.net1 = nn.Sequential(*net1)
self.net2 = nn.Sequential(*net2)
self.net3 = nn.Sequential(*net3)
self.net4 = nn.Sequential(*net4)
self.v1 = nn.Sequential(*v1)
self.v2 = nn.Sequential(*v2)
self.pi1 = nn.Sequential(*pi1)
self.pi2 = nn.Sequential(*pi2)
self.v3 = nn.Linear(fcsize, 1)
self.pi3 = nn.Linear(fcsize, c_prime * h_prime * w_prime)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
h1 = F.relu(self.net1(x))
h2 = F.relu(self.net2(h1)) + h1
h3 = F.relu(self.net3(h2)) + h2
h4 = F.relu(self.net4(h3)) + h3
v1 = F.relu(self.v1(h4.flatten(1)))
v2 = F.relu(self.v2(v1))
v = torch.tanh(self.v3(v2))
pi_logit1 = F.relu(self.pi1(h4.flatten(1)))
pi_logit2 = F.relu(self.pi2(pi_logit1))
pi_logit = self.pi3(pi_logit2)
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit.flatten(1), 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/loss.py
================================================
import torch
from torch import nn
import torch.nn.functional as F
from typing import Tuple
def mcts_loss(
self,
model,
batch,
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
predicts = getattr(self, "predicts", 0)
x = batch["s"]
v = batch["v"]
pi = batch["pi"]
pi_mask = batch["pi_mask"]
predict_pi = batch["predict_pi"] if predicts > 0 else None
predict_pi_mask = batch["predict_pi_mask"] if predicts > 0 else None
pi = pi.flatten(1)
if predicts > 0:
pred_v, pred_logit, pred_predict_logit = model._forward(x, return_logit=True)
else:
pred_v, pred_logit, *_ = model._forward(x, return_logit=True)
pi_mask = pi_mask.view(pred_logit.shape);
pred_logit = pred_logit * pi_mask - 400 * (1 - pi_mask)
if predicts > 0:
predict_pi_err = (F.mse_loss(pred_predict_logit, predict_pi, reduction="none") * predict_pi_mask).flatten(2).sum(2).flatten(1).mean(1)
v_err = F.mse_loss(pred_v, v, reduction="none").squeeze(1)
pred_log_pi = nn.functional.log_softmax(pred_logit.flatten(1), dim=1).view_as(pred_logit) * pi_mask
pi_err = -(pred_log_pi * pi).sum(1)
err = v_err * 1.5 + pi_err + (predict_pi_err * 0.1 if predicts > 0 else 0)
return err.mean(), v_err.detach().mean(), pi_err.detach().mean(), (predict_pi_err.detach().mean() if predicts > 0 else None)
================================================
FILE: pypolygames/model_zoo/nano_conv_logit_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class NanoConvLogitModel(torch.jit.ScriptModule):
__constants__ = ["c_prime", "h_prime", "w_prime", "net"]
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Hex13"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
if h_prime != h or w_prime != w:
raise RuntimeError(
f'The game "{self.game_name}" is not eligible to a conv-computed logit '
f'model such as "{self.__class__.__name__}" - try with '
f'"{self.__class__.__name__.replace("ConvLogit", "FCLogit")}" instead'
)
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
net = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
if bn or bn_affine:
net.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
self.net = nn.Sequential(*net)
self.v = nn.Linear(int(nnsize * c) * h * w, 1)
self.pi_logit = nn.Conv2d(
int(nnsize * c), c_prime, nnks, stride=stride, padding=padding, dilation=dilation
)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
h = F.relu(self.net(x))
v = torch.tanh(self.v(h.flatten(1)))
pi_logit = self.pi_logit(h).flatten(1)
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit.flatten(1), 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/nano_fc_logit_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class NanoFCLogitModel(torch.jit.ScriptModule):
__constants__ = ["c_prime", "h_prime", "w_prime", "net"]
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Connect4"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
net = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
if bn or bn_affine:
net.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine)
)
self.net = nn.Sequential(*net)
self.v = nn.Linear(int(nnsize * c) * h * w, 1)
self.pi_logit = nn.Linear(int(nnsize * c) * h * w, c_prime * h_prime * w_prime)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
h = F.relu(self.net(x))
v = torch.tanh(self.v(h.flatten(1)))
pi_logit = self.pi_logit(h.flatten(1))
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit.flatten(1), 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/res_conv_conv_logit_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class ResConvConvLogitModel(torch.jit.ScriptModule):
__constants__ = [
"c_prime",
"h_prime",
"w_prime",
"nb_layers_per_net",
"mono",
"resnets",
]
DEFAULT_NB_NETS = 5
DEFAULT_NB_LAYERS_PER_NET = 3
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_POOLING = False
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Hex13"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
if h_prime != h or w_prime != w:
raise RuntimeError(
f'The game "{self.game_name}" is not eligible to a conv-computed logit '
f'model such as "{self.__class__.__name__}" - try with '
f'"{self.__class__.__name__.replace("ConvLogit", "FCLogit")}" instead'
)
# nb resnets
if model_params.nb_nets is None:
model_params.nb_nets = self.DEFAULT_NB_NETS
nb_nets = model_params.nb_nets
# nb layers per resnet
if model_params.nb_layers_per_net is None:
model_params.nb_layers_per_net = self.DEFAULT_NB_LAYERS_PER_NET
nb_layers_per_net = model_params.nb_layers_per_net
self.nb_layers_per_net = nb_layers_per_net
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# pooling
if model_params.pooling is None:
model_params.pooling = self.DEFAULT_POOLING
pooling = model_params.pooling
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
mono = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
resnet_list = []
for i in range(nb_nets):
nets = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
for _ in range(nb_layers_per_net)
]
if bn or bn_affine:
for j in range(nb_layers_per_net):
nets[j] = nn.Sequential(
nets[j],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine
),
)
if pooling:
for j in range(nb_layers_per_net):
nets[j] = nn.Sequential(
nets[j],
nn.MaxPool2d(
kernel_size=nnks,
padding=padding,
stride=stride,
dilation=dilation,
),
)
resnet_list.append(nets)
if bn or bn_affine:
mono.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine),
)
for i in range(nb_nets):
for j in range(nb_layers_per_net):
resnet_list[i][j] = nn.Sequential(
resnet_list[i][j],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine
),
)
for i in range(nb_nets):
resnet_list[i] = nn.ModuleList(resnet_list[i])
self.mono = nn.Sequential(*mono)
self.resnets = nn.ModuleList(resnet_list)
self.v = nn.Linear(int(nnsize * c) * h * w, 1)
self.pi_logit = nn.Conv2d(
int(nnsize * c), c_prime, nnks, stride=stride, padding=padding, dilation=dilation
)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
previous_block = self.mono(x) # linear transformation only
for resnet in self.resnets:
sublayer_no = 0
h = F.relu(previous_block) # initial activation
for net in resnet:
if sublayer_no < self.nb_layers_per_net - 1:
h = F.relu(net(h))
else:
h = net(h) + previous_block # linear transformation only
previous_block = h
sublayer_no = sublayer_no + 1
h = F.relu(previous_block) # final activation
v = torch.tanh(self.v(h.flatten(1)))
pi_logit = self.pi_logit(h).flatten(1)
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit, 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, self.h_prime, self.w_prime)
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/res_conv_conv_logit_pool_model.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class ResConvConvLogitPoolModel(torch.jit.ScriptModule):
__constants__ = [
"c_prime",
"h_prime",
"w_prime",
"nb_layers_per_net",
"mono",
"resnets",
]
DEFAULT_NB_NETS = 5
DEFAULT_NB_LAYERS_PER_NET = 3
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_POOLING = False
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Hex13"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
if h_prime != h or w_prime != w:
raise RuntimeError(
f'The game "{self.game_name}" is not eligible to a conv-computed logit '
f'model such as "{self.__class__.__name__}" - try with '
f'"{self.__class__.__name__.replace("ConvLogit", "FCLogit")}" instead'
)
# nb resnets
if model_params.nb_nets is None:
model_params.nb_nets = self.DEFAULT_NB_NETS
nb_nets = model_params.nb_nets
# nb layers per resnet
if model_params.nb_layers_per_net is None:
model_params.nb_layers_per_net = self.DEFAULT_NB_LAYERS_PER_NET
nb_layers_per_net = model_params.nb_layers_per_net
self.nb_layers_per_net = nb_layers_per_net
# nn size
if model_params.nnsize is None:
model_params.nnsize = self.DEFAULT_NNSIZE
nnsize = model_params.nnsize
# kernel size
if model_params.nnks is None:
model_params.nnks = self.DEFAULT_NNKS
nnks = model_params.nnks
# stride
stride = self.DEFAULT_STRIDE
# dilation
dilation = self.DEFAULT_DILATION
# padding
padding = zutils.get_consistent_padding_from_nnks(nnks=nnks, dilation=dilation)
# pooling
if model_params.pooling is None:
model_params.pooling = self.DEFAULT_POOLING
pooling = model_params.pooling
# batch norm
if model_params.bn is None:
model_params.bn = self.DEFAULT_BN
bn = model_params.bn
# # batch norm affine
# if model_params.bn_affine is None:
# model_params.bn_affine = self.DEFAULT_BN_AFFINE
# bn_affine = model_params.bn_affine
bn_affine = bn
self.model_params = model_params
batchnorm_momentum = model_params.batchnorm_momentum
mono = [
nn.Conv2d(
c,
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
]
resnet_list = []
for i in range(nb_nets):
nets = [
nn.Conv2d(
int(nnsize * c),
int(nnsize * c),
nnks,
stride=stride,
padding=padding,
dilation=dilation,
bias=not bn_affine,
)
for _ in range(nb_layers_per_net)
]
if bn or bn_affine:
for j in range(nb_layers_per_net):
nets[j] = nn.Sequential(
nets[j],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine, momentum=batchnorm_momentum
),
)
if pooling:
for j in range(nb_layers_per_net):
nets[j] = nn.Sequential(
nets[j],
nn.MaxPool2d(
kernel_size=nnks,
padding=padding,
stride=stride,
dilation=dilation,
),
)
resnet_list.append(nets)
if bn or bn_affine:
mono.append(
nn.BatchNorm2d(int(nnsize * c), track_running_stats=True, affine=bn_affine, momentum=batchnorm_momentum),
)
for i in range(nb_nets):
for j in range(nb_layers_per_net):
resnet_list[i][j] = nn.Sequential(
resnet_list[i][j],
nn.BatchNorm2d(
int(nnsize * c), track_running_stats=True, affine=bn_affine
),
)
for i in range(nb_nets):
resnet_list[i] = nn.ModuleList(resnet_list[i])
self.mono = nn.Sequential(*mono)
self.resnets = nn.ModuleList(resnet_list)
self.v = nn.Linear(2 * int(nnsize * c), 1)
self.pi_logit = nn.Conv2d(
int(nnsize * c), c_prime, nnks, stride=stride, padding=padding, dilation=dilation
)
@torch.jit.script_method
def _forward(self, x: torch.Tensor, return_logit: bool):
previous_block = self.mono(x) # linear transformation only
for resnet in self.resnets:
sublayer_no = 0
h = F.relu(previous_block) # initial activation
for net in resnet:
if sublayer_no < self.nb_layers_per_net - 1:
h = F.relu(net(h))
else:
h = net(h) + previous_block # linear transformation only
previous_block = h
sublayer_no = sublayer_no + 1
h = F.relu(previous_block) # final activation
pool = torch.cat((F.adaptive_max_pool2d(h, 1), F.adaptive_avg_pool2d(h, 1)), 1)
v = torch.tanh(self.v(pool.flatten(1)))
pi_logit = self.pi_logit(h).flatten(1)
if return_logit:
return v, pi_logit
s = pi_logit.shape
pi = F.softmax(pi_logit, 1).reshape(s)
return v, pi
@torch.jit.script_method
def forward(self, x: torch.Tensor):
v, pi_logit = self._forward(x, True)
pi_logit = pi_logit.view(-1, self.c_prime, x.size(2), x.size(3))
reply = {"v": v, "pi_logit": pi_logit}
return reply
================================================
FILE: pypolygames/model_zoo/res_conv_conv_logit_pool_model_v2.py
================================================
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from torch import nn
import torch.nn.functional as F
from typing import Tuple
from . import utils as zutils
from ..params import GameParams, ModelParams
from .. import utils
@zutils.register_model
class ResConvConvLogitPoolModelV2(torch.jit.ScriptModule):
__constants__ = [
"c_prime",
"h_prime",
"w_prime",
"nb_layers_per_net",
"mono",
"resnets",
"global_pooling",
]
DEFAULT_NB_NETS = 5
DEFAULT_NB_LAYERS_PER_NET = 3
DEFAULT_NNSIZE = 2
DEFAULT_NNKS = 3
DEFAULT_STRIDE = 1
DEFAULT_DILATION = 1
DEFAULT_POOLING = False
DEFAULT_BN = False
# DEFAULT_BN_AFFINE = False
default_game_name = "Hex13"
def __init__(self, game_params: GameParams, model_params: ModelParams):
torch.jit.ScriptModule.__init__(self)
if game_params.game_name is None:
game_params.game_name = self.__class__.default_game_name
self.game_name = game_params.game_name
self.game_params = game_params
info = zutils.get_game_info(game_params)
c, h, w = self.c, self.h, self.w = info["feature_size"][:3]
r_c, r_h, r_w = info["raw_feature_size"]
c_prime, h_prime, w_prime = self.c_prime, self.h_prime, self.w_prime = info[
"action_size"
][:3]
if h_prime != h or w_prime != w:
raise RuntimeError(
f'The game "{self.game_name}" is not eligible to a conv-computed logit '
f'model such as "{self.__class__.__name__}" - try with '
f'"{self.__class__.__name__.replace("ConvLogit", "FCLogit")}" instead'
)
# nb resnets
if model_params.nb_nets is None:
model_params.nb_nets = self.DEFAULT_NB_NETS
nb_nets = model_params.nb_nets
# nb layers per resnet
if model_params.nb_layers_per_net is None:
model_params.nb_layers_per_net = self.DEFAULT_NB_LAYERS_PER_NET
nb_layers_per_net = model_params.nb_layers_per_net
self.nb_layers_per_net = nb_layers_per_net
gitextract_jldjsds9/
├── .circleci/
│ └── config.yml
├── .clang-format
├── .github/
│ ├── CONTRIBUTING.md
│ ├── ISSUE_TEMPLATE.md
│ └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── build.sh
├── littlegolem/
│ └── play_littlegolem.py
├── nix/
│ ├── Dockerfile
│ ├── Dockerfile-centos7-nix
│ ├── README.md
│ ├── get-nvidia.sh
│ ├── shell-cpu.nix
│ └── shell-cuda.nix
├── pypolygames/
│ ├── __init__.py
│ ├── __main__.py
│ ├── convert.py
│ ├── draw_model.py
│ ├── env_creation_helpers.py
│ ├── evaluation.py
│ ├── human.py
│ ├── model_zoo/
│ │ ├── __init__.py
│ │ ├── amazons_model.py
│ │ ├── connect4_benchmark_model.py
│ │ ├── deep_conv_conv_logit_model.py
│ │ ├── deep_conv_fc_logit_model.py
│ │ ├── generic_model.py
│ │ ├── loss.py
│ │ ├── nano_conv_logit_model.py
│ │ ├── nano_fc_logit_model.py
│ │ ├── res_conv_conv_logit_model.py
│ │ ├── res_conv_conv_logit_pool_model.py
│ │ ├── res_conv_conv_logit_pool_model_v2.py
│ │ ├── res_conv_fc_logit_model.py
│ │ ├── u_conv_conv_logit_model.py
│ │ ├── u_conv_fc_logit_model.py
│ │ └── utils.py
│ ├── params.py
│ ├── tests/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── data/
│ │ │ ├── BlockGo.txt
│ │ │ ├── Breakthrough.txt
│ │ │ ├── ChineseCheckers.txt
│ │ │ ├── DiceShogi.txt
│ │ │ ├── Einstein.txt
│ │ │ ├── GameOfTheAmazons.txt
│ │ │ ├── Havannah5.txt
│ │ │ ├── Havannah8.txt
│ │ │ ├── Hex11.txt
│ │ │ ├── Hex13.txt
│ │ │ ├── KyotoShogi.txt
│ │ │ ├── Minishogi.txt
│ │ │ ├── Othello10.txt
│ │ │ ├── Othello16.txt
│ │ │ ├── OthelloOpt10.txt
│ │ │ ├── OthelloOpt16.txt
│ │ │ ├── Surakarta.txt
│ │ │ └── Tristannogo.txt
│ │ ├── test_interactions.py
│ │ ├── test_mcts.py
│ │ ├── test_params.py
│ │ └── test_zoo.py
│ ├── training.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── assert_utils.py
│ │ ├── checkpoint.py
│ │ ├── command_history.py
│ │ ├── helpers.py
│ │ ├── listings.py
│ │ ├── logger.py
│ │ ├── multi_counter.py
│ │ ├── plotter.py
│ │ ├── restrack.py
│ │ ├── result.py
│ │ └── test_listings.py
│ └── weight_init.py
├── singularity/
│ ├── README.md
│ ├── environment.yml
│ └── polygames.def
├── src/
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── async.h
│ │ ├── thread_id.cc
│ │ ├── thread_id.h
│ │ ├── threads.cc
│ │ └── threads.h
│ ├── core/
│ │ ├── actor.h
│ │ ├── actor_player.h
│ │ ├── forward_player.h
│ │ ├── game.cc
│ │ ├── game.h
│ │ ├── human_player.h
│ │ ├── model_manager.cc
│ │ ├── model_manager.h
│ │ ├── player.h
│ │ ├── pybind.cc
│ │ ├── replay_buffer.cc
│ │ ├── replay_buffer.h
│ │ ├── state.cc
│ │ ├── state.h
│ │ ├── test_state.cc
│ │ └── utils.h
│ ├── distributed/
│ │ ├── distributed.cc
│ │ ├── distributed.h
│ │ ├── ib.cc
│ │ ├── network.cc
│ │ ├── network.h
│ │ ├── rdma.h
│ │ ├── rdma_nop.cc
│ │ └── rpc.h
│ ├── games/
│ │ ├── amazons.cc
│ │ ├── amazons.h
│ │ ├── block_go.h
│ │ ├── breakthrough.cc
│ │ ├── breakthrough.h
│ │ ├── breakthrough_state.h
│ │ ├── chess.cc
│ │ ├── chess.h
│ │ ├── chinesecheckers.cc
│ │ ├── chinesecheckers.h
│ │ ├── chinesecheckers_defines.h
│ │ ├── commons/
│ │ │ ├── chessboard.h
│ │ │ ├── hash.h
│ │ │ └── player.h
│ │ ├── connect6.h
│ │ ├── connect6_state.h
│ │ ├── connectfour.h
│ │ ├── diceshogi.h
│ │ ├── diceshogi_state.h
│ │ ├── einstein.h
│ │ ├── game_action.h
│ │ ├── game_base.cc
│ │ ├── game_base.h
│ │ ├── game_player.h
│ │ ├── game_state.h
│ │ ├── gomoku_swap2.cc
│ │ ├── gomoku_swap2.h
│ │ ├── havannah.h
│ │ ├── havannah_state.h
│ │ ├── hex.h
│ │ ├── hex_state.h
│ │ ├── kyotoshogi.h
│ │ ├── kyotoshogi_state.h
│ │ ├── ludii/
│ │ │ ├── README.md
│ │ │ ├── jni_utils.cc
│ │ │ ├── jni_utils.h
│ │ │ ├── ludii_game_wrapper.cc
│ │ │ ├── ludii_game_wrapper.h
│ │ │ ├── ludii_state_wrapper.cc
│ │ │ └── ludii_state_wrapper.h
│ │ ├── mastermind_state.cc
│ │ ├── mastermind_state.h
│ │ ├── minesweeper.cc
│ │ ├── minesweeper_common.h
│ │ ├── minesweeper_csp_vkms/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ConnectedComponent.h
│ │ │ ├── CspStrategy.h
│ │ │ ├── SolutionSet.h
│ │ │ ├── SolutionSetSampler.h
│ │ │ └── csp_vkms.cc
│ │ ├── minesweeper_state.h
│ │ ├── minishogi.h
│ │ ├── mnkgame.h
│ │ ├── nogo_action.cc
│ │ ├── nogo_action.h
│ │ ├── nogo_bitboard.h
│ │ ├── nogo_game.cc
│ │ ├── nogo_game.h
│ │ ├── nogo_position.h
│ │ ├── nogo_state.cc
│ │ ├── nogo_state.h
│ │ ├── nogo_zestate.h
│ │ ├── othello.h
│ │ ├── othello_opt.cc
│ │ ├── othello_opt.h
│ │ ├── outeropengomoku_new.h
│ │ ├── shogi.h
│ │ ├── surakarta.h
│ │ ├── surakarta_state.h
│ │ ├── tristan_nogo.cc
│ │ ├── tristan_nogo.h
│ │ ├── tristannogo_state.h
│ │ ├── weakschur/
│ │ │ ├── SchurMatrix.cpp
│ │ │ ├── SchurMatrix.hpp
│ │ │ ├── SchurVector.cpp
│ │ │ ├── SchurVector.hpp
│ │ │ ├── WeakSchur.cpp
│ │ │ ├── WeakSchur.hpp
│ │ │ └── weakschur_state.h
│ │ ├── yinsh.cc
│ │ └── yinsh.h
│ ├── mcts/
│ │ ├── CMakeLists.txt
│ │ ├── actor.h
│ │ ├── mcts.cc
│ │ ├── mcts.h
│ │ ├── node.cc
│ │ ├── node.h
│ │ ├── player.h
│ │ ├── pybind.cc
│ │ ├── storage.cc
│ │ ├── storage.h
│ │ ├── test.cc
│ │ ├── types.h
│ │ └── utils.h
│ ├── third_party/
│ │ ├── asio/
│ │ │ ├── associated_allocator.hpp
│ │ │ ├── associated_executor.hpp
│ │ │ ├── async_result.hpp
│ │ │ ├── awaitable.hpp
│ │ │ ├── basic_datagram_socket.hpp
│ │ │ ├── basic_deadline_timer.hpp
│ │ │ ├── basic_io_object.hpp
│ │ │ ├── basic_raw_socket.hpp
│ │ │ ├── basic_seq_packet_socket.hpp
│ │ │ ├── basic_serial_port.hpp
│ │ │ ├── basic_signal_set.hpp
│ │ │ ├── basic_socket.hpp
│ │ │ ├── basic_socket_acceptor.hpp
│ │ │ ├── basic_socket_iostream.hpp
│ │ │ ├── basic_socket_streambuf.hpp
│ │ │ ├── basic_stream_socket.hpp
│ │ │ ├── basic_streambuf.hpp
│ │ │ ├── basic_streambuf_fwd.hpp
│ │ │ ├── basic_waitable_timer.hpp
│ │ │ ├── bind_executor.hpp
│ │ │ ├── buffer.hpp
│ │ │ ├── buffered_read_stream.hpp
│ │ │ ├── buffered_read_stream_fwd.hpp
│ │ │ ├── buffered_stream.hpp
│ │ │ ├── buffered_stream_fwd.hpp
│ │ │ ├── buffered_write_stream.hpp
│ │ │ ├── buffered_write_stream_fwd.hpp
│ │ │ ├── buffers_iterator.hpp
│ │ │ ├── co_spawn.hpp
│ │ │ ├── completion_condition.hpp
│ │ │ ├── compose.hpp
│ │ │ ├── connect.hpp
│ │ │ ├── coroutine.hpp
│ │ │ ├── deadline_timer.hpp
│ │ │ ├── defer.hpp
│ │ │ ├── detached.hpp
│ │ │ ├── detail/
│ │ │ │ ├── array.hpp
│ │ │ │ ├── array_fwd.hpp
│ │ │ │ ├── assert.hpp
│ │ │ │ ├── atomic_count.hpp
│ │ │ │ ├── base_from_completion_cond.hpp
│ │ │ │ ├── bind_handler.hpp
│ │ │ │ ├── buffer_resize_guard.hpp
│ │ │ │ ├── buffer_sequence_adapter.hpp
│ │ │ │ ├── buffered_stream_storage.hpp
│ │ │ │ ├── call_stack.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── chrono_time_traits.hpp
│ │ │ │ ├── completion_handler.hpp
│ │ │ │ ├── concurrency_hint.hpp
│ │ │ │ ├── conditionally_enabled_event.hpp
│ │ │ │ ├── conditionally_enabled_mutex.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── consuming_buffers.hpp
│ │ │ │ ├── cstddef.hpp
│ │ │ │ ├── cstdint.hpp
│ │ │ │ ├── date_time_fwd.hpp
│ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ ├── dependent_type.hpp
│ │ │ │ ├── descriptor_ops.hpp
│ │ │ │ ├── descriptor_read_op.hpp
│ │ │ │ ├── descriptor_write_op.hpp
│ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ ├── event.hpp
│ │ │ │ ├── eventfd_select_interrupter.hpp
│ │ │ │ ├── executor_function.hpp
│ │ │ │ ├── executor_op.hpp
│ │ │ │ ├── fd_set_adapter.hpp
│ │ │ │ ├── fenced_block.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── future.hpp
│ │ │ │ ├── gcc_arm_fenced_block.hpp
│ │ │ │ ├── gcc_hppa_fenced_block.hpp
│ │ │ │ ├── gcc_sync_fenced_block.hpp
│ │ │ │ ├── gcc_x86_fenced_block.hpp
│ │ │ │ ├── global.hpp
│ │ │ │ ├── handler_alloc_helpers.hpp
│ │ │ │ ├── handler_cont_helpers.hpp
│ │ │ │ ├── handler_invoke_helpers.hpp
│ │ │ │ ├── handler_tracking.hpp
│ │ │ │ ├── handler_type_requirements.hpp
│ │ │ │ ├── handler_work.hpp
│ │ │ │ ├── hash_map.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── buffer_sequence_adapter.ipp
│ │ │ │ │ ├── descriptor_ops.ipp
│ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ ├── dev_poll_reactor.ipp
│ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ ├── epoll_reactor.ipp
│ │ │ │ │ ├── eventfd_select_interrupter.ipp
│ │ │ │ │ ├── handler_tracking.ipp
│ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ ├── kqueue_reactor.ipp
│ │ │ │ │ ├── null_event.ipp
│ │ │ │ │ ├── pipe_select_interrupter.ipp
│ │ │ │ │ ├── posix_event.ipp
│ │ │ │ │ ├── posix_mutex.ipp
│ │ │ │ │ ├── posix_thread.ipp
│ │ │ │ │ ├── posix_tss_ptr.ipp
│ │ │ │ │ ├── reactive_descriptor_service.ipp
│ │ │ │ │ ├── reactive_serial_port_service.ipp
│ │ │ │ │ ├── reactive_socket_service_base.ipp
│ │ │ │ │ ├── resolver_service_base.ipp
│ │ │ │ │ ├── scheduler.ipp
│ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ ├── select_reactor.ipp
│ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ ├── service_registry.ipp
│ │ │ │ │ ├── signal_set_service.ipp
│ │ │ │ │ ├── socket_ops.ipp
│ │ │ │ │ ├── socket_select_interrupter.ipp
│ │ │ │ │ ├── strand_executor_service.hpp
│ │ │ │ │ ├── strand_executor_service.ipp
│ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ ├── strand_service.ipp
│ │ │ │ │ ├── throw_error.ipp
│ │ │ │ │ ├── timer_queue_ptime.ipp
│ │ │ │ │ ├── timer_queue_set.ipp
│ │ │ │ │ ├── win_event.ipp
│ │ │ │ │ ├── win_iocp_handle_service.ipp
│ │ │ │ │ ├── win_iocp_io_context.hpp
│ │ │ │ │ ├── win_iocp_io_context.ipp
│ │ │ │ │ ├── win_iocp_serial_port_service.ipp
│ │ │ │ │ ├── win_iocp_socket_service_base.ipp
│ │ │ │ │ ├── win_mutex.ipp
│ │ │ │ │ ├── win_object_handle_service.ipp
│ │ │ │ │ ├── win_static_mutex.ipp
│ │ │ │ │ ├── win_thread.ipp
│ │ │ │ │ ├── win_tss_ptr.ipp
│ │ │ │ │ ├── winrt_ssocket_service_base.ipp
│ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ ├── winrt_timer_scheduler.ipp
│ │ │ │ │ └── winsock_init.ipp
│ │ │ │ ├── io_control.hpp
│ │ │ │ ├── io_object_executor.hpp
│ │ │ │ ├── io_object_impl.hpp
│ │ │ │ ├── is_buffer_sequence.hpp
│ │ │ │ ├── is_executor.hpp
│ │ │ │ ├── keyword_tss_ptr.hpp
│ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ ├── limits.hpp
│ │ │ │ ├── local_free_on_block_exit.hpp
│ │ │ │ ├── macos_fenced_block.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── mutex.hpp
│ │ │ │ ├── non_const_lvalue.hpp
│ │ │ │ ├── noncopyable.hpp
│ │ │ │ ├── null_event.hpp
│ │ │ │ ├── null_fenced_block.hpp
│ │ │ │ ├── null_global.hpp
│ │ │ │ ├── null_mutex.hpp
│ │ │ │ ├── null_reactor.hpp
│ │ │ │ ├── null_signal_blocker.hpp
│ │ │ │ ├── null_socket_service.hpp
│ │ │ │ ├── null_static_mutex.hpp
│ │ │ │ ├── null_thread.hpp
│ │ │ │ ├── null_tss_ptr.hpp
│ │ │ │ ├── object_pool.hpp
│ │ │ │ ├── old_win_sdk_compat.hpp
│ │ │ │ ├── op_queue.hpp
│ │ │ │ ├── operation.hpp
│ │ │ │ ├── pipe_select_interrupter.hpp
│ │ │ │ ├── pop_options.hpp
│ │ │ │ ├── posix_event.hpp
│ │ │ │ ├── posix_fd_set_adapter.hpp
│ │ │ │ ├── posix_global.hpp
│ │ │ │ ├── posix_mutex.hpp
│ │ │ │ ├── posix_signal_blocker.hpp
│ │ │ │ ├── posix_static_mutex.hpp
│ │ │ │ ├── posix_thread.hpp
│ │ │ │ ├── posix_tss_ptr.hpp
│ │ │ │ ├── push_options.hpp
│ │ │ │ ├── reactive_descriptor_service.hpp
│ │ │ │ ├── reactive_null_buffers_op.hpp
│ │ │ │ ├── reactive_serial_port_service.hpp
│ │ │ │ ├── reactive_socket_accept_op.hpp
│ │ │ │ ├── reactive_socket_connect_op.hpp
│ │ │ │ ├── reactive_socket_recv_op.hpp
│ │ │ │ ├── reactive_socket_recvfrom_op.hpp
│ │ │ │ ├── reactive_socket_recvmsg_op.hpp
│ │ │ │ ├── reactive_socket_send_op.hpp
│ │ │ │ ├── reactive_socket_sendto_op.hpp
│ │ │ │ ├── reactive_socket_service.hpp
│ │ │ │ ├── reactive_socket_service_base.hpp
│ │ │ │ ├── reactive_wait_op.hpp
│ │ │ │ ├── reactor.hpp
│ │ │ │ ├── reactor_fwd.hpp
│ │ │ │ ├── reactor_op.hpp
│ │ │ │ ├── reactor_op_queue.hpp
│ │ │ │ ├── recycling_allocator.hpp
│ │ │ │ ├── regex_fwd.hpp
│ │ │ │ ├── resolve_endpoint_op.hpp
│ │ │ │ ├── resolve_op.hpp
│ │ │ │ ├── resolve_query_op.hpp
│ │ │ │ ├── resolver_service.hpp
│ │ │ │ ├── resolver_service_base.hpp
│ │ │ │ ├── scheduler.hpp
│ │ │ │ ├── scheduler_operation.hpp
│ │ │ │ ├── scheduler_thread_info.hpp
│ │ │ │ ├── scoped_lock.hpp
│ │ │ │ ├── scoped_ptr.hpp
│ │ │ │ ├── select_interrupter.hpp
│ │ │ │ ├── select_reactor.hpp
│ │ │ │ ├── service_registry.hpp
│ │ │ │ ├── signal_blocker.hpp
│ │ │ │ ├── signal_handler.hpp
│ │ │ │ ├── signal_init.hpp
│ │ │ │ ├── signal_op.hpp
│ │ │ │ ├── signal_set_service.hpp
│ │ │ │ ├── socket_holder.hpp
│ │ │ │ ├── socket_ops.hpp
│ │ │ │ ├── socket_option.hpp
│ │ │ │ ├── socket_select_interrupter.hpp
│ │ │ │ ├── socket_types.hpp
│ │ │ │ ├── solaris_fenced_block.hpp
│ │ │ │ ├── static_mutex.hpp
│ │ │ │ ├── std_event.hpp
│ │ │ │ ├── std_fenced_block.hpp
│ │ │ │ ├── std_global.hpp
│ │ │ │ ├── std_mutex.hpp
│ │ │ │ ├── std_static_mutex.hpp
│ │ │ │ ├── std_thread.hpp
│ │ │ │ ├── strand_executor_service.hpp
│ │ │ │ ├── strand_service.hpp
│ │ │ │ ├── string_view.hpp
│ │ │ │ ├── thread.hpp
│ │ │ │ ├── thread_context.hpp
│ │ │ │ ├── thread_group.hpp
│ │ │ │ ├── thread_info_base.hpp
│ │ │ │ ├── throw_error.hpp
│ │ │ │ ├── throw_exception.hpp
│ │ │ │ ├── timer_queue.hpp
│ │ │ │ ├── timer_queue_base.hpp
│ │ │ │ ├── timer_queue_ptime.hpp
│ │ │ │ ├── timer_queue_set.hpp
│ │ │ │ ├── timer_scheduler.hpp
│ │ │ │ ├── timer_scheduler_fwd.hpp
│ │ │ │ ├── tss_ptr.hpp
│ │ │ │ ├── type_traits.hpp
│ │ │ │ ├── variadic_templates.hpp
│ │ │ │ ├── wait_handler.hpp
│ │ │ │ ├── wait_op.hpp
│ │ │ │ ├── win_event.hpp
│ │ │ │ ├── win_fd_set_adapter.hpp
│ │ │ │ ├── win_fenced_block.hpp
│ │ │ │ ├── win_global.hpp
│ │ │ │ ├── win_iocp_handle_read_op.hpp
│ │ │ │ ├── win_iocp_handle_service.hpp
│ │ │ │ ├── win_iocp_handle_write_op.hpp
│ │ │ │ ├── win_iocp_io_context.hpp
│ │ │ │ ├── win_iocp_null_buffers_op.hpp
│ │ │ │ ├── win_iocp_operation.hpp
│ │ │ │ ├── win_iocp_overlapped_op.hpp
│ │ │ │ ├── win_iocp_overlapped_ptr.hpp
│ │ │ │ ├── win_iocp_serial_port_service.hpp
│ │ │ │ ├── win_iocp_socket_accept_op.hpp
│ │ │ │ ├── win_iocp_socket_connect_op.hpp
│ │ │ │ ├── win_iocp_socket_recv_op.hpp
│ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp
│ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp
│ │ │ │ ├── win_iocp_socket_send_op.hpp
│ │ │ │ ├── win_iocp_socket_service.hpp
│ │ │ │ ├── win_iocp_socket_service_base.hpp
│ │ │ │ ├── win_iocp_thread_info.hpp
│ │ │ │ ├── win_iocp_wait_op.hpp
│ │ │ │ ├── win_mutex.hpp
│ │ │ │ ├── win_object_handle_service.hpp
│ │ │ │ ├── win_static_mutex.hpp
│ │ │ │ ├── win_thread.hpp
│ │ │ │ ├── win_tss_ptr.hpp
│ │ │ │ ├── winapp_thread.hpp
│ │ │ │ ├── wince_thread.hpp
│ │ │ │ ├── winrt_async_manager.hpp
│ │ │ │ ├── winrt_async_op.hpp
│ │ │ │ ├── winrt_resolve_op.hpp
│ │ │ │ ├── winrt_resolver_service.hpp
│ │ │ │ ├── winrt_socket_connect_op.hpp
│ │ │ │ ├── winrt_socket_recv_op.hpp
│ │ │ │ ├── winrt_socket_send_op.hpp
│ │ │ │ ├── winrt_ssocket_service.hpp
│ │ │ │ ├── winrt_ssocket_service_base.hpp
│ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ ├── winrt_utils.hpp
│ │ │ │ ├── winsock_init.hpp
│ │ │ │ ├── work_dispatcher.hpp
│ │ │ │ └── wrapped_handler.hpp
│ │ │ ├── dispatch.hpp
│ │ │ ├── error.hpp
│ │ │ ├── error_code.hpp
│ │ │ ├── execution_context.hpp
│ │ │ ├── executor.hpp
│ │ │ ├── executor_work_guard.hpp
│ │ │ ├── generic/
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ └── impl/
│ │ │ │ │ └── endpoint.ipp
│ │ │ │ ├── raw_protocol.hpp
│ │ │ │ ├── seq_packet_protocol.hpp
│ │ │ │ └── stream_protocol.hpp
│ │ │ ├── handler_alloc_hook.hpp
│ │ │ ├── handler_continuation_hook.hpp
│ │ │ ├── handler_invoke_hook.hpp
│ │ │ ├── high_resolution_timer.hpp
│ │ │ ├── impl/
│ │ │ │ ├── awaitable.hpp
│ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ ├── co_spawn.hpp
│ │ │ │ ├── compose.hpp
│ │ │ │ ├── connect.hpp
│ │ │ │ ├── defer.hpp
│ │ │ │ ├── detached.hpp
│ │ │ │ ├── dispatch.hpp
│ │ │ │ ├── error.ipp
│ │ │ │ ├── error_code.ipp
│ │ │ │ ├── execution_context.hpp
│ │ │ │ ├── execution_context.ipp
│ │ │ │ ├── executor.hpp
│ │ │ │ ├── executor.ipp
│ │ │ │ ├── handler_alloc_hook.ipp
│ │ │ │ ├── io_context.hpp
│ │ │ │ ├── io_context.ipp
│ │ │ │ ├── post.hpp
│ │ │ │ ├── read.hpp
│ │ │ │ ├── read_at.hpp
│ │ │ │ ├── read_until.hpp
│ │ │ │ ├── redirect_error.hpp
│ │ │ │ ├── serial_port_base.hpp
│ │ │ │ ├── serial_port_base.ipp
│ │ │ │ ├── spawn.hpp
│ │ │ │ ├── src.cpp
│ │ │ │ ├── src.hpp
│ │ │ │ ├── system_context.hpp
│ │ │ │ ├── system_context.ipp
│ │ │ │ ├── system_executor.hpp
│ │ │ │ ├── thread_pool.hpp
│ │ │ │ ├── thread_pool.ipp
│ │ │ │ ├── use_awaitable.hpp
│ │ │ │ ├── use_future.hpp
│ │ │ │ ├── write.hpp
│ │ │ │ └── write_at.hpp
│ │ │ ├── io_context.hpp
│ │ │ ├── io_context_strand.hpp
│ │ │ ├── io_service.hpp
│ │ │ ├── io_service_strand.hpp
│ │ │ ├── ip/
│ │ │ │ ├── address.hpp
│ │ │ │ ├── address_v4.hpp
│ │ │ │ ├── address_v4_iterator.hpp
│ │ │ │ ├── address_v4_range.hpp
│ │ │ │ ├── address_v6.hpp
│ │ │ │ ├── address_v6_iterator.hpp
│ │ │ │ ├── address_v6_range.hpp
│ │ │ │ ├── bad_address_cast.hpp
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── basic_resolver.hpp
│ │ │ │ ├── basic_resolver_entry.hpp
│ │ │ │ ├── basic_resolver_iterator.hpp
│ │ │ │ ├── basic_resolver_query.hpp
│ │ │ │ ├── basic_resolver_results.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ └── socket_option.hpp
│ │ │ │ ├── host_name.hpp
│ │ │ │ ├── icmp.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── address.hpp
│ │ │ │ │ ├── address.ipp
│ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ ├── address_v4.ipp
│ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ ├── address_v6.ipp
│ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ ├── host_name.ipp
│ │ │ │ │ ├── network_v4.hpp
│ │ │ │ │ ├── network_v4.ipp
│ │ │ │ │ ├── network_v6.hpp
│ │ │ │ │ └── network_v6.ipp
│ │ │ │ ├── multicast.hpp
│ │ │ │ ├── network_v4.hpp
│ │ │ │ ├── network_v6.hpp
│ │ │ │ ├── resolver_base.hpp
│ │ │ │ ├── resolver_query_base.hpp
│ │ │ │ ├── tcp.hpp
│ │ │ │ ├── udp.hpp
│ │ │ │ ├── unicast.hpp
│ │ │ │ └── v6_only.hpp
│ │ │ ├── is_executor.hpp
│ │ │ ├── is_read_buffered.hpp
│ │ │ ├── is_write_buffered.hpp
│ │ │ ├── local/
│ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ ├── connect_pair.hpp
│ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ └── impl/
│ │ │ │ │ └── endpoint.ipp
│ │ │ │ └── stream_protocol.hpp
│ │ │ ├── packaged_task.hpp
│ │ │ ├── placeholders.hpp
│ │ │ ├── posix/
│ │ │ │ ├── basic_descriptor.hpp
│ │ │ │ ├── basic_stream_descriptor.hpp
│ │ │ │ ├── descriptor.hpp
│ │ │ │ ├── descriptor_base.hpp
│ │ │ │ └── stream_descriptor.hpp
│ │ │ ├── post.hpp
│ │ │ ├── read.hpp
│ │ │ ├── read_at.hpp
│ │ │ ├── read_until.hpp
│ │ │ ├── redirect_error.hpp
│ │ │ ├── serial_port.hpp
│ │ │ ├── serial_port_base.hpp
│ │ │ ├── signal_set.hpp
│ │ │ ├── socket_base.hpp
│ │ │ ├── spawn.hpp
│ │ │ ├── ssl/
│ │ │ │ ├── context.hpp
│ │ │ │ ├── context_base.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── buffered_handshake_op.hpp
│ │ │ │ │ ├── engine.hpp
│ │ │ │ │ ├── handshake_op.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── engine.ipp
│ │ │ │ │ │ └── openssl_init.ipp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── openssl_init.hpp
│ │ │ │ │ ├── openssl_types.hpp
│ │ │ │ │ ├── password_callback.hpp
│ │ │ │ │ ├── read_op.hpp
│ │ │ │ │ ├── shutdown_op.hpp
│ │ │ │ │ ├── stream_core.hpp
│ │ │ │ │ ├── verify_callback.hpp
│ │ │ │ │ └── write_op.hpp
│ │ │ │ ├── error.hpp
│ │ │ │ ├── impl/
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── context.ipp
│ │ │ │ │ ├── error.ipp
│ │ │ │ │ ├── rfc2818_verification.ipp
│ │ │ │ │ └── src.hpp
│ │ │ │ ├── rfc2818_verification.hpp
│ │ │ │ ├── stream.hpp
│ │ │ │ ├── stream_base.hpp
│ │ │ │ ├── verify_context.hpp
│ │ │ │ └── verify_mode.hpp
│ │ │ ├── ssl.hpp
│ │ │ ├── steady_timer.hpp
│ │ │ ├── strand.hpp
│ │ │ ├── streambuf.hpp
│ │ │ ├── system_context.hpp
│ │ │ ├── system_error.hpp
│ │ │ ├── system_executor.hpp
│ │ │ ├── system_timer.hpp
│ │ │ ├── this_coro.hpp
│ │ │ ├── thread.hpp
│ │ │ ├── thread_pool.hpp
│ │ │ ├── time_traits.hpp
│ │ │ ├── ts/
│ │ │ │ ├── buffer.hpp
│ │ │ │ ├── executor.hpp
│ │ │ │ ├── internet.hpp
│ │ │ │ ├── io_context.hpp
│ │ │ │ ├── net.hpp
│ │ │ │ ├── netfwd.hpp
│ │ │ │ ├── socket.hpp
│ │ │ │ └── timer.hpp
│ │ │ ├── unyield.hpp
│ │ │ ├── use_awaitable.hpp
│ │ │ ├── use_future.hpp
│ │ │ ├── uses_executor.hpp
│ │ │ ├── version.hpp
│ │ │ ├── wait_traits.hpp
│ │ │ ├── windows/
│ │ │ │ ├── basic_object_handle.hpp
│ │ │ │ ├── basic_overlapped_handle.hpp
│ │ │ │ ├── basic_random_access_handle.hpp
│ │ │ │ ├── basic_stream_handle.hpp
│ │ │ │ ├── object_handle.hpp
│ │ │ │ ├── overlapped_handle.hpp
│ │ │ │ ├── overlapped_ptr.hpp
│ │ │ │ ├── random_access_handle.hpp
│ │ │ │ └── stream_handle.hpp
│ │ │ ├── write.hpp
│ │ │ ├── write_at.hpp
│ │ │ └── yield.hpp
│ │ ├── asio.hpp
│ │ ├── concurrentqueue/
│ │ │ ├── LICENSE.md
│ │ │ ├── README.md
│ │ │ ├── benchmarks/
│ │ │ │ ├── benchmarks.cpp
│ │ │ │ ├── boost/
│ │ │ │ │ ├── LICENSE_1_0.txt
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── array.hpp
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── atomic/
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ ├── capabilities.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ │ ├── atomic_template.hpp
│ │ │ │ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ │ │ │ ├── caps_windows.hpp
│ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ ├── int_sizes.hpp
│ │ │ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ │ │ ├── link.hpp
│ │ │ │ │ │ │ ├── lockpool.hpp
│ │ │ │ │ │ │ ├── operations.hpp
│ │ │ │ │ │ │ ├── operations_fwd.hpp
│ │ │ │ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ │ │ │ ├── ops_emulated.hpp
│ │ │ │ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ │ │ │ ├── ops_windows.hpp
│ │ │ │ │ │ │ ├── pause.hpp
│ │ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ │ └── storage_type.hpp
│ │ │ │ │ │ └── fences.hpp
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── config/
│ │ │ │ │ │ ├── abi/
│ │ │ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ │ ├── compiler/
│ │ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ │ ├── clang.hpp
│ │ │ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ │ ├── kai.hpp
│ │ │ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ │ │ └── xlcpp.hpp
│ │ │ │ │ │ ├── no_tr1/
│ │ │ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ │ └── utility.hpp
│ │ │ │ │ │ ├── platform/
│ │ │ │ │ │ │ ├── aix.hpp
│ │ │ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ │ │ ├── beos.hpp
│ │ │ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ │ │ ├── irix.hpp
│ │ │ │ │ │ │ ├── linux.hpp
│ │ │ │ │ │ │ ├── macos.hpp
│ │ │ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ │ │ ├── vms.hpp
│ │ │ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ │ │ └── win32.hpp
│ │ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ │ ├── requires_threads.hpp
│ │ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ │ │ ├── modena.hpp
│ │ │ │ │ │ │ ├── msl.hpp
│ │ │ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ │ │ └── vacpp.hpp
│ │ │ │ │ │ ├── suffix.hpp
│ │ │ │ │ │ ├── user.hpp
│ │ │ │ │ │ └── warning_disable.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── core/
│ │ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ │ └── swap.hpp
│ │ │ │ │ ├── cstdint.hpp
│ │ │ │ │ ├── current_function.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── is_xxx.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ ├── exception/
│ │ │ │ │ │ └── exception.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── hash/
│ │ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ ├── limits.hpp
│ │ │ │ │ ├── lockfree/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ │ ├── copy_payload.hpp
│ │ │ │ │ │ │ ├── freelist.hpp
│ │ │ │ │ │ │ ├── parameter.hpp
│ │ │ │ │ │ │ ├── prefix.hpp
│ │ │ │ │ │ │ ├── tagged_ptr.hpp
│ │ │ │ │ │ │ ├── tagged_ptr_dcas.hpp
│ │ │ │ │ │ │ └── tagged_ptr_ptrcompression.hpp
│ │ │ │ │ │ ├── policies.hpp
│ │ │ │ │ │ └── queue.hpp
│ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ ├── mpl/
│ │ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ │ ├── O1_size_fwd.hpp
│ │ │ │ │ │ ├── always.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── arg_fwd.hpp
│ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ ├── at_fwd.hpp
│ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ ├── O1_size_impl.hpp
│ │ │ │ │ │ │ ├── adl_barrier.hpp
│ │ │ │ │ │ │ ├── arg_typedef.hpp
│ │ │ │ │ │ │ ├── arity.hpp
│ │ │ │ │ │ │ ├── arity_spec.hpp
│ │ │ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ │ │ ├── common_name_wknd.hpp
│ │ │ │ │ │ │ ├── config/
│ │ │ │ │ │ │ │ ├── adl.hpp
│ │ │ │ │ │ │ │ ├── arrays.hpp
│ │ │ │ │ │ │ │ ├── bcc.hpp
│ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ │ │ │ ├── ctps.hpp
│ │ │ │ │ │ │ │ ├── dmc_ambiguous_ctps.hpp
│ │ │ │ │ │ │ │ ├── dtp.hpp
│ │ │ │ │ │ │ │ ├── eti.hpp
│ │ │ │ │ │ │ │ ├── forwarding.hpp
│ │ │ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ │ │ ├── gpu.hpp
│ │ │ │ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ │ │ │ ├── integral.hpp
│ │ │ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ │ │ ├── msvc.hpp
│ │ │ │ │ │ │ │ ├── msvc_typename.hpp
│ │ │ │ │ │ │ │ ├── nttp.hpp
│ │ │ │ │ │ │ │ ├── operators.hpp
│ │ │ │ │ │ │ │ ├── overload_resolution.hpp
│ │ │ │ │ │ │ │ ├── pp_counter.hpp
│ │ │ │ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ │ │ │ ├── static_constant.hpp
│ │ │ │ │ │ │ │ ├── ttp.hpp
│ │ │ │ │ │ │ │ ├── use_preprocessed.hpp
│ │ │ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ │ │ ├── count_args.hpp
│ │ │ │ │ │ │ ├── find_if_pred.hpp
│ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ ├── fold_impl_body.hpp
│ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ │ │ ├── has_begin.hpp
│ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ ├── has_rebind.hpp
│ │ │ │ │ │ │ ├── has_size.hpp
│ │ │ │ │ │ │ ├── has_tag.hpp
│ │ │ │ │ │ │ ├── has_type.hpp
│ │ │ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ │ │ ├── integral_wrapper.hpp
│ │ │ │ │ │ │ ├── is_msvc_eti_arg.hpp
│ │ │ │ │ │ │ ├── iter_apply.hpp
│ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ ├── lambda_arity_param.hpp
│ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ ├── lambda_spec.hpp
│ │ │ │ │ │ │ ├── lambda_support.hpp
│ │ │ │ │ │ │ ├── logical_op.hpp
│ │ │ │ │ │ │ ├── msvc_dtw.hpp
│ │ │ │ │ │ │ ├── msvc_eti_base.hpp
│ │ │ │ │ │ │ ├── msvc_is_class.hpp
│ │ │ │ │ │ │ ├── msvc_never_true.hpp
│ │ │ │ │ │ │ ├── msvc_type.hpp
│ │ │ │ │ │ │ ├── na.hpp
│ │ │ │ │ │ │ ├── na_assert.hpp
│ │ │ │ │ │ │ ├── na_fwd.hpp
│ │ │ │ │ │ │ ├── na_spec.hpp
│ │ │ │ │ │ │ ├── nested_type_wknd.hpp
│ │ │ │ │ │ │ ├── nttp_decl.hpp
│ │ │ │ │ │ │ ├── overload_names.hpp
│ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ ├── bcc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── bcc551/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── bcc_pre590/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── gcc/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── msvc60/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── msvc70/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── mwcw/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── no_ctps/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ ├── no_ttp/
│ │ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ │ └── plain/
│ │ │ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ ├── add.hpp
│ │ │ │ │ │ │ │ ├── def_params_tail.hpp
│ │ │ │ │ │ │ │ ├── default_params.hpp
│ │ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ │ ├── ext_params.hpp
│ │ │ │ │ │ │ │ ├── filter_params.hpp
│ │ │ │ │ │ │ │ ├── params.hpp
│ │ │ │ │ │ │ │ ├── partial_spec_params.hpp
│ │ │ │ │ │ │ │ ├── range.hpp
│ │ │ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ │ │ ├── sub.hpp
│ │ │ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ │ │ ├── ptr_to_ref.hpp
│ │ │ │ │ │ │ ├── push_front_impl.hpp
│ │ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ │ ├── reverse_fold_impl_body.hpp
│ │ │ │ │ │ │ ├── sequence_wrapper.hpp
│ │ │ │ │ │ │ ├── static_cast.hpp
│ │ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ │ ├── template_arity_fwd.hpp
│ │ │ │ │ │ │ ├── traits_lambda_spec.hpp
│ │ │ │ │ │ │ ├── type_wrapper.hpp
│ │ │ │ │ │ │ ├── value_wknd.hpp
│ │ │ │ │ │ │ └── yes_no.hpp
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ │ ├── begin_end_fwd.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bool.hpp
│ │ │ │ │ │ ├── bool_fwd.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── clear_fwd.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── empty_fwd.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── erase_fwd.hpp
│ │ │ │ │ │ ├── erase_key_fwd.hpp
│ │ │ │ │ │ ├── eval_if.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ ├── front_fwd.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── has_key_fwd.hpp
│ │ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── if.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_fwd.hpp
│ │ │ │ │ │ ├── insert_range_fwd.hpp
│ │ │ │ │ │ ├── int.hpp
│ │ │ │ │ │ ├── int_fwd.hpp
│ │ │ │ │ │ ├── integral_c.hpp
│ │ │ │ │ │ ├── integral_c_fwd.hpp
│ │ │ │ │ │ ├── integral_c_tag.hpp
│ │ │ │ │ │ ├── is_placeholder.hpp
│ │ │ │ │ │ ├── iter_fold_if.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── iterator_tags.hpp
│ │ │ │ │ │ ├── key_type_fwd.hpp
│ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ ├── lambda_fwd.hpp
│ │ │ │ │ │ ├── limits/
│ │ │ │ │ │ │ ├── arity.hpp
│ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ └── unrolling.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ │ │ │ ├── item.hpp
│ │ │ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ │ │ ├── numbered.hpp
│ │ │ │ │ │ │ │ ├── numbered_c.hpp
│ │ │ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ └── plain/
│ │ │ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ │ └── tag.hpp
│ │ │ │ │ │ │ ├── list0.hpp
│ │ │ │ │ │ │ ├── list0_c.hpp
│ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── logical.hpp
│ │ │ │ │ │ ├── long.hpp
│ │ │ │ │ │ ├── long_fwd.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── next_prior.hpp
│ │ │ │ │ │ ├── not.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── pop_front_fwd.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── protect.hpp
│ │ │ │ │ │ ├── push_back_fwd.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ ├── push_front_fwd.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ ├── same_as.hpp
│ │ │ │ │ │ ├── sequence_tag.hpp
│ │ │ │ │ │ ├── sequence_tag_fwd.hpp
│ │ │ │ │ │ ├── set/
│ │ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── erase_impl.hpp
│ │ │ │ │ │ │ │ ├── erase_key_impl.hpp
│ │ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ │ │ │ ├── insert_range_impl.hpp
│ │ │ │ │ │ │ │ ├── item.hpp
│ │ │ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ │ │ ├── key_type_impl.hpp
│ │ │ │ │ │ │ │ ├── set0.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── tag.hpp
│ │ │ │ │ │ │ │ └── value_type_impl.hpp
│ │ │ │ │ │ │ └── set0.hpp
│ │ │ │ │ │ ├── size_fwd.hpp
│ │ │ │ │ │ ├── size_t.hpp
│ │ │ │ │ │ ├── size_t_fwd.hpp
│ │ │ │ │ │ ├── value_type_fwd.hpp
│ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ └── void_fwd.hpp
│ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ ├── parameter/
│ │ │ │ │ │ ├── aux_/
│ │ │ │ │ │ │ ├── arg_list.hpp
│ │ │ │ │ │ │ ├── cast.hpp
│ │ │ │ │ │ │ ├── default.hpp
│ │ │ │ │ │ │ ├── is_maybe.hpp
│ │ │ │ │ │ │ ├── overloads.hpp
│ │ │ │ │ │ │ ├── parameter_requirements.hpp
│ │ │ │ │ │ │ ├── parenthesized_type.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ │ │ └── for_each.hpp
│ │ │ │ │ │ │ ├── result_of0.hpp
│ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ ├── tag.hpp
│ │ │ │ │ │ │ ├── tagged_argument.hpp
│ │ │ │ │ │ │ ├── template_keyword.hpp
│ │ │ │ │ │ │ ├── unwrap_cv_reference.hpp
│ │ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ │ └── yesno.hpp
│ │ │ │ │ │ ├── binding.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── keyword.hpp
│ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ ├── match.hpp
│ │ │ │ │ │ ├── name.hpp
│ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ │ └── value_type.hpp
│ │ │ │ │ ├── parameter.hpp
│ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ │ ├── add.hpp
│ │ │ │ │ │ │ ├── dec.hpp
│ │ │ │ │ │ │ ├── inc.hpp
│ │ │ │ │ │ │ └── sub.hpp
│ │ │ │ │ │ ├── array/
│ │ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ └── size.hpp
│ │ │ │ │ │ ├── cat.hpp
│ │ │ │ │ │ ├── comma_if.hpp
│ │ │ │ │ │ ├── comparison/
│ │ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ └── not_equal.hpp
│ │ │ │ │ │ ├── config/
│ │ │ │ │ │ │ └── config.hpp
│ │ │ │ │ │ ├── control/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ ├── msvc/
│ │ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ │ ├── expr_if.hpp
│ │ │ │ │ │ │ ├── expr_iif.hpp
│ │ │ │ │ │ │ ├── if.hpp
│ │ │ │ │ │ │ ├── iif.hpp
│ │ │ │ │ │ │ └── while.hpp
│ │ │ │ │ │ ├── debug/
│ │ │ │ │ │ │ └── error.hpp
│ │ │ │ │ │ ├── dec.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── auto_rec.hpp
│ │ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ └── auto_rec.hpp
│ │ │ │ │ │ │ ├── is_binary.hpp
│ │ │ │ │ │ │ ├── is_nullary.hpp
│ │ │ │ │ │ │ └── split.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ ├── enum_params.hpp
│ │ │ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ │ │ ├── expr_if.hpp
│ │ │ │ │ │ ├── facilities/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_empty.hpp
│ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ ├── expand.hpp
│ │ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ │ ├── intercept.hpp
│ │ │ │ │ │ │ ├── is_1.hpp
│ │ │ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ │ │ ├── is_empty_variadic.hpp
│ │ │ │ │ │ │ └── overload.hpp
│ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── inc.hpp
│ │ │ │ │ │ ├── iterate.hpp
│ │ │ │ │ │ ├── iteration/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── bounds/
│ │ │ │ │ │ │ │ │ ├── lower1.hpp
│ │ │ │ │ │ │ │ │ ├── lower2.hpp
│ │ │ │ │ │ │ │ │ ├── lower3.hpp
│ │ │ │ │ │ │ │ │ ├── lower4.hpp
│ │ │ │ │ │ │ │ │ ├── lower5.hpp
│ │ │ │ │ │ │ │ │ ├── upper1.hpp
│ │ │ │ │ │ │ │ │ ├── upper2.hpp
│ │ │ │ │ │ │ │ │ ├── upper3.hpp
│ │ │ │ │ │ │ │ │ ├── upper4.hpp
│ │ │ │ │ │ │ │ │ └── upper5.hpp
│ │ │ │ │ │ │ │ ├── finish.hpp
│ │ │ │ │ │ │ │ ├── iter/
│ │ │ │ │ │ │ │ │ ├── forward1.hpp
│ │ │ │ │ │ │ │ │ ├── forward2.hpp
│ │ │ │ │ │ │ │ │ ├── forward3.hpp
│ │ │ │ │ │ │ │ │ ├── forward4.hpp
│ │ │ │ │ │ │ │ │ ├── forward5.hpp
│ │ │ │ │ │ │ │ │ ├── reverse1.hpp
│ │ │ │ │ │ │ │ │ ├── reverse2.hpp
│ │ │ │ │ │ │ │ │ ├── reverse3.hpp
│ │ │ │ │ │ │ │ │ ├── reverse4.hpp
│ │ │ │ │ │ │ │ │ └── reverse5.hpp
│ │ │ │ │ │ │ │ ├── local.hpp
│ │ │ │ │ │ │ │ ├── rlocal.hpp
│ │ │ │ │ │ │ │ ├── self.hpp
│ │ │ │ │ │ │ │ └── start.hpp
│ │ │ │ │ │ │ ├── iterate.hpp
│ │ │ │ │ │ │ ├── local.hpp
│ │ │ │ │ │ │ └── self.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── adt.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── fold_left.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ ├── fold_right.hpp
│ │ │ │ │ │ │ ├── for_each_i.hpp
│ │ │ │ │ │ │ └── reverse.hpp
│ │ │ │ │ │ ├── logical/
│ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ │ ├── bool.hpp
│ │ │ │ │ │ │ ├── compl.hpp
│ │ │ │ │ │ │ └── not.hpp
│ │ │ │ │ │ ├── punctuation/
│ │ │ │ │ │ │ ├── comma.hpp
│ │ │ │ │ │ │ ├── comma_if.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ ├── repetition/
│ │ │ │ │ │ │ ├── deduce_r.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── dmc/
│ │ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ │ ├── edg/
│ │ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ │ │ └── msvc/
│ │ │ │ │ │ │ │ └── for.hpp
│ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ ├── enum_binary_params.hpp
│ │ │ │ │ │ │ ├── enum_params.hpp
│ │ │ │ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ │ │ │ ├── enum_shifted.hpp
│ │ │ │ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ │ │ │ ├── enum_trailing.hpp
│ │ │ │ │ │ │ ├── enum_trailing_params.hpp
│ │ │ │ │ │ │ ├── for.hpp
│ │ │ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ │ │ └── repeat_from_to.hpp
│ │ │ │ │ │ ├── selection/
│ │ │ │ │ │ │ └── max.hpp
│ │ │ │ │ │ ├── seq/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ │ │ │ └── split.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ ├── enum.hpp
│ │ │ │ │ │ │ ├── first_n.hpp
│ │ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ ├── for_each_i.hpp
│ │ │ │ │ │ │ ├── for_each_product.hpp
│ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ ├── rest_n.hpp
│ │ │ │ │ │ │ ├── seq.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ └── subseq.hpp
│ │ │ │ │ │ ├── slot/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── counter.hpp
│ │ │ │ │ │ │ │ ├── def.hpp
│ │ │ │ │ │ │ │ ├── shared.hpp
│ │ │ │ │ │ │ │ ├── slot1.hpp
│ │ │ │ │ │ │ │ ├── slot2.hpp
│ │ │ │ │ │ │ │ ├── slot3.hpp
│ │ │ │ │ │ │ │ ├── slot4.hpp
│ │ │ │ │ │ │ │ └── slot5.hpp
│ │ │ │ │ │ │ └── slot.hpp
│ │ │ │ │ │ ├── stringize.hpp
│ │ │ │ │ │ ├── tuple/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── is_single_return.hpp
│ │ │ │ │ │ │ ├── eat.hpp
│ │ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ │ ├── rem.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ └── to_list.hpp
│ │ │ │ │ │ └── variadic/
│ │ │ │ │ │ ├── elem.hpp
│ │ │ │ │ │ └── size.hpp
│ │ │ │ │ ├── static_assert.hpp
│ │ │ │ │ ├── swap.hpp
│ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ ├── type_traits/
│ │ │ │ │ │ ├── add_const.hpp
│ │ │ │ │ │ ├── add_lvalue_reference.hpp
│ │ │ │ │ │ ├── add_reference.hpp
│ │ │ │ │ │ ├── add_rvalue_reference.hpp
│ │ │ │ │ │ ├── add_volatile.hpp
│ │ │ │ │ │ ├── conditional.hpp
│ │ │ │ │ │ ├── declval.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ ├── is_function_ptr_helper.hpp
│ │ │ │ │ │ │ ├── is_function_ptr_tester.hpp
│ │ │ │ │ │ │ ├── is_mem_fun_pointer_impl.hpp
│ │ │ │ │ │ │ ├── is_mem_fun_pointer_tester.hpp
│ │ │ │ │ │ │ └── yes_no_type.hpp
│ │ │ │ │ │ ├── has_trivial_assign.hpp
│ │ │ │ │ │ ├── has_trivial_destructor.hpp
│ │ │ │ │ │ ├── integral_constant.hpp
│ │ │ │ │ │ ├── intrinsics.hpp
│ │ │ │ │ │ ├── is_abstract.hpp
│ │ │ │ │ │ ├── is_arithmetic.hpp
│ │ │ │ │ │ ├── is_array.hpp
│ │ │ │ │ │ ├── is_assignable.hpp
│ │ │ │ │ │ ├── is_base_and_derived.hpp
│ │ │ │ │ │ ├── is_class.hpp
│ │ │ │ │ │ ├── is_const.hpp
│ │ │ │ │ │ ├── is_convertible.hpp
│ │ │ │ │ │ ├── is_destructible.hpp
│ │ │ │ │ │ ├── is_enum.hpp
│ │ │ │ │ │ ├── is_floating_point.hpp
│ │ │ │ │ │ ├── is_function.hpp
│ │ │ │ │ │ ├── is_integral.hpp
│ │ │ │ │ │ ├── is_lvalue_reference.hpp
│ │ │ │ │ │ ├── is_member_function_pointer.hpp
│ │ │ │ │ │ ├── is_member_pointer.hpp
│ │ │ │ │ │ ├── is_pod.hpp
│ │ │ │ │ │ ├── is_pointer.hpp
│ │ │ │ │ │ ├── is_polymorphic.hpp
│ │ │ │ │ │ ├── is_reference.hpp
│ │ │ │ │ │ ├── is_rvalue_reference.hpp
│ │ │ │ │ │ ├── is_same.hpp
│ │ │ │ │ │ ├── is_scalar.hpp
│ │ │ │ │ │ ├── is_signed.hpp
│ │ │ │ │ │ ├── is_union.hpp
│ │ │ │ │ │ ├── is_unsigned.hpp
│ │ │ │ │ │ ├── is_void.hpp
│ │ │ │ │ │ ├── is_volatile.hpp
│ │ │ │ │ │ ├── make_signed.hpp
│ │ │ │ │ │ ├── remove_const.hpp
│ │ │ │ │ │ ├── remove_cv.hpp
│ │ │ │ │ │ └── remove_reference.hpp
│ │ │ │ │ ├── utility/
│ │ │ │ │ │ ├── declval.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── result_of_iterate.hpp
│ │ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ │ └── result_of.hpp
│ │ │ │ │ └── version.hpp
│ │ │ │ ├── boostqueue.h
│ │ │ │ ├── cpuid.cpp
│ │ │ │ ├── cpuid.h
│ │ │ │ ├── extract_graph_data.py
│ │ │ │ ├── lockbasedqueue.h
│ │ │ │ ├── simplelockfree.h
│ │ │ │ ├── stdqueue.h
│ │ │ │ ├── tbb/
│ │ │ │ │ ├── COPYING
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── aggregator.h
│ │ │ │ │ ├── aligned_space.h
│ │ │ │ │ ├── arena.cpp
│ │ │ │ │ ├── arena.h
│ │ │ │ │ ├── atomic.h
│ │ │ │ │ ├── blocked_range.h
│ │ │ │ │ ├── blocked_range2d.h
│ │ │ │ │ ├── blocked_range3d.h
│ │ │ │ │ ├── cache_aligned_allocator.cpp
│ │ │ │ │ ├── cache_aligned_allocator.h
│ │ │ │ │ ├── cilk-tbb-interop.h
│ │ │ │ │ ├── combinable.h
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── condition_variable
│ │ │ │ │ │ ├── ppl.h
│ │ │ │ │ │ ├── thread
│ │ │ │ │ │ └── tuple
│ │ │ │ │ ├── concurrent_hash_map.cpp
│ │ │ │ │ ├── concurrent_hash_map.h
│ │ │ │ │ ├── concurrent_lru_cache.h
│ │ │ │ │ ├── concurrent_monitor.cpp
│ │ │ │ │ ├── concurrent_monitor.h
│ │ │ │ │ ├── concurrent_priority_queue.h
│ │ │ │ │ ├── concurrent_queue.cpp
│ │ │ │ │ ├── concurrent_queue.h
│ │ │ │ │ ├── concurrent_unordered_map.h
│ │ │ │ │ ├── concurrent_unordered_set.h
│ │ │ │ │ ├── concurrent_vector.cpp
│ │ │ │ │ ├── concurrent_vector.h
│ │ │ │ │ ├── condition_variable.cpp
│ │ │ │ │ ├── critical_section.cpp
│ │ │ │ │ ├── critical_section.h
│ │ │ │ │ ├── custom_scheduler.h
│ │ │ │ │ ├── dynamic_link.cpp
│ │ │ │ │ ├── dynamic_link.h
│ │ │ │ │ ├── enumerable_thread_specific.h
│ │ │ │ │ ├── flow_graph.h
│ │ │ │ │ ├── governor.cpp
│ │ │ │ │ ├── governor.h
│ │ │ │ │ ├── ia32-masm/
│ │ │ │ │ │ ├── atomic_support.asm
│ │ │ │ │ │ ├── itsx.asm
│ │ │ │ │ │ └── lock_byte.asm
│ │ │ │ │ ├── ia64-gas/
│ │ │ │ │ │ ├── atomic_support.s
│ │ │ │ │ │ ├── ia64_misc.s
│ │ │ │ │ │ ├── lock_byte.s
│ │ │ │ │ │ ├── log2.s
│ │ │ │ │ │ └── pause.s
│ │ │ │ │ ├── ibm_aix51/
│ │ │ │ │ │ └── atomic_support.c
│ │ │ │ │ ├── intel64-masm/
│ │ │ │ │ │ ├── atomic_support.asm
│ │ │ │ │ │ ├── intel64_misc.asm
│ │ │ │ │ │ └── itsx.asm
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── _aggregator_impl.h
│ │ │ │ │ │ ├── _concurrent_queue_impl.h
│ │ │ │ │ │ ├── _concurrent_unordered_impl.h
│ │ │ │ │ │ ├── _flow_graph_impl.h
│ │ │ │ │ │ ├── _flow_graph_indexer_impl.h
│ │ │ │ │ │ ├── _flow_graph_item_buffer_impl.h
│ │ │ │ │ │ ├── _flow_graph_join_impl.h
│ │ │ │ │ │ ├── _flow_graph_node_impl.h
│ │ │ │ │ │ ├── _flow_graph_tagged_buffer_impl.h
│ │ │ │ │ │ ├── _flow_graph_trace_impl.h
│ │ │ │ │ │ ├── _flow_graph_types_impl.h
│ │ │ │ │ │ ├── _mutex_padding.h
│ │ │ │ │ │ ├── _range_iterator.h
│ │ │ │ │ │ ├── _tbb_strings.h
│ │ │ │ │ │ ├── _tbb_windef.h
│ │ │ │ │ │ ├── _x86_eliding_mutex_impl.h
│ │ │ │ │ │ └── _x86_rtm_rw_mutex_impl.h
│ │ │ │ │ ├── intrusive_list.h
│ │ │ │ │ ├── itt_notify.cpp
│ │ │ │ │ ├── itt_notify.h
│ │ │ │ │ ├── lin32-tbb-export.def
│ │ │ │ │ ├── lin32-tbb-export.lst
│ │ │ │ │ ├── lin64-tbb-export.def
│ │ │ │ │ ├── lin64-tbb-export.lst
│ │ │ │ │ ├── lin64ipf-tbb-export.def
│ │ │ │ │ ├── lin64ipf-tbb-export.lst
│ │ │ │ │ ├── mac32-tbb-export.def
│ │ │ │ │ ├── mac32-tbb-export.lst
│ │ │ │ │ ├── mac64-tbb-export.def
│ │ │ │ │ ├── mac64-tbb-export.lst
│ │ │ │ │ ├── machine/
│ │ │ │ │ │ ├── gcc_armv7.h
│ │ │ │ │ │ ├── gcc_generic.h
│ │ │ │ │ │ ├── gcc_ia32_common.h
│ │ │ │ │ │ ├── gcc_itsx.h
│ │ │ │ │ │ ├── ibm_aix51.h
│ │ │ │ │ │ ├── icc_generic.h
│ │ │ │ │ │ ├── linux_common.h
│ │ │ │ │ │ ├── linux_ia32.h
│ │ │ │ │ │ ├── linux_ia64.h
│ │ │ │ │ │ ├── linux_intel64.h
│ │ │ │ │ │ ├── mac_ppc.h
│ │ │ │ │ │ ├── macos_common.h
│ │ │ │ │ │ ├── mic_common.h
│ │ │ │ │ │ ├── msvc_armv7.h
│ │ │ │ │ │ ├── msvc_ia32_common.h
│ │ │ │ │ │ ├── sunos_sparc.h
│ │ │ │ │ │ ├── windows_api.h
│ │ │ │ │ │ ├── windows_ia32.h
│ │ │ │ │ │ ├── windows_intel64.h
│ │ │ │ │ │ └── xbox360_ppc.h
│ │ │ │ │ ├── mailbox.h
│ │ │ │ │ ├── market.cpp
│ │ │ │ │ ├── market.h
│ │ │ │ │ ├── memory_pool.h
│ │ │ │ │ ├── mutex.cpp
│ │ │ │ │ ├── mutex.h
│ │ │ │ │ ├── null_mutex.h
│ │ │ │ │ ├── null_rw_mutex.h
│ │ │ │ │ ├── observer_proxy.cpp
│ │ │ │ │ ├── observer_proxy.h
│ │ │ │ │ ├── parallel_do.h
│ │ │ │ │ ├── parallel_for.h
│ │ │ │ │ ├── parallel_for_each.h
│ │ │ │ │ ├── parallel_invoke.h
│ │ │ │ │ ├── parallel_reduce.h
│ │ │ │ │ ├── parallel_scan.h
│ │ │ │ │ ├── parallel_sort.h
│ │ │ │ │ ├── parallel_while.h
│ │ │ │ │ ├── partitioner.h
│ │ │ │ │ ├── pipeline.cpp
│ │ │ │ │ ├── pipeline.h
│ │ │ │ │ ├── private_server.cpp
│ │ │ │ │ ├── queuing_mutex.cpp
│ │ │ │ │ ├── queuing_mutex.h
│ │ │ │ │ ├── queuing_rw_mutex.cpp
│ │ │ │ │ ├── queuing_rw_mutex.h
│ │ │ │ │ ├── reader_writer_lock.cpp
│ │ │ │ │ ├── reader_writer_lock.h
│ │ │ │ │ ├── recursive_mutex.cpp
│ │ │ │ │ ├── recursive_mutex.h
│ │ │ │ │ ├── runtime_loader.h
│ │ │ │ │ ├── scalable_allocator.h
│ │ │ │ │ ├── scheduler.cpp
│ │ │ │ │ ├── scheduler.h
│ │ │ │ │ ├── scheduler_common.h
│ │ │ │ │ ├── scheduler_utility.h
│ │ │ │ │ ├── semaphore.cpp
│ │ │ │ │ ├── semaphore.h
│ │ │ │ │ ├── spin_mutex.cpp
│ │ │ │ │ ├── spin_mutex.h
│ │ │ │ │ ├── spin_rw_mutex.cpp
│ │ │ │ │ ├── spin_rw_mutex.h
│ │ │ │ │ ├── task.cpp
│ │ │ │ │ ├── task.h
│ │ │ │ │ ├── task_arena.h
│ │ │ │ │ ├── task_group.h
│ │ │ │ │ ├── task_group_context.cpp
│ │ │ │ │ ├── task_scheduler_init.h
│ │ │ │ │ ├── task_scheduler_observer.h
│ │ │ │ │ ├── task_stream.h
│ │ │ │ │ ├── tbb.h
│ │ │ │ │ ├── tbb_allocator.h
│ │ │ │ │ ├── tbb_assert_impl.h
│ │ │ │ │ ├── tbb_config.h
│ │ │ │ │ ├── tbb_exception.h
│ │ │ │ │ ├── tbb_machine.h
│ │ │ │ │ ├── tbb_main.cpp
│ │ │ │ │ ├── tbb_main.h
│ │ │ │ │ ├── tbb_misc.cpp
│ │ │ │ │ ├── tbb_misc.h
│ │ │ │ │ ├── tbb_misc_ex.cpp
│ │ │ │ │ ├── tbb_profiling.h
│ │ │ │ │ ├── tbb_resource.rc
│ │ │ │ │ ├── tbb_statistics.cpp
│ │ │ │ │ ├── tbb_statistics.h
│ │ │ │ │ ├── tbb_stddef.h
│ │ │ │ │ ├── tbb_thread.cpp
│ │ │ │ │ ├── tbb_thread.h
│ │ │ │ │ ├── tbb_version.h
│ │ │ │ │ ├── tbbmalloc_proxy.h
│ │ │ │ │ ├── tick_count.h
│ │ │ │ │ ├── tls.h
│ │ │ │ │ ├── tools_api/
│ │ │ │ │ │ ├── disable_warnings.h
│ │ │ │ │ │ ├── internal/
│ │ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ │ ├── ittnotify.h
│ │ │ │ │ │ ├── ittnotify_config.h
│ │ │ │ │ │ ├── ittnotify_static.c
│ │ │ │ │ │ ├── ittnotify_static.h
│ │ │ │ │ │ ├── ittnotify_types.h
│ │ │ │ │ │ ├── legacy/
│ │ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ │ └── prototype/
│ │ │ │ │ │ └── ittnotify.h
│ │ │ │ │ ├── version_string.ver
│ │ │ │ │ ├── win32-tbb-export.def
│ │ │ │ │ ├── win32-tbb-export.lst
│ │ │ │ │ ├── win64-gcc-tbb-export.def
│ │ │ │ │ ├── win64-gcc-tbb-export.lst
│ │ │ │ │ ├── win64-tbb-export.def
│ │ │ │ │ ├── win64-tbb-export.lst
│ │ │ │ │ ├── winrt-tbb-export.lst
│ │ │ │ │ ├── x86_rtm_rw_mutex.cpp
│ │ │ │ │ └── xbox360-tbb-export.def
│ │ │ │ ├── tbbqueue.h
│ │ │ │ └── wrappers.h
│ │ │ ├── blockingconcurrentqueue.h
│ │ │ ├── concurrentqueue.h
│ │ │ ├── internal/
│ │ │ │ └── concurrentqueue_internal_debug.h
│ │ │ ├── samples.md
│ │ │ └── tests/
│ │ │ ├── CDSChecker/
│ │ │ │ ├── README.txt
│ │ │ │ ├── corealgo.h
│ │ │ │ ├── enqueue_dequeue_many.cpp
│ │ │ │ └── enqueue_dequeue_one.cpp
│ │ │ ├── common/
│ │ │ │ ├── simplethread.cpp
│ │ │ │ ├── simplethread.h
│ │ │ │ ├── systemtime.cpp
│ │ │ │ └── systemtime.h
│ │ │ ├── corealgos.h
│ │ │ ├── fuzztests/
│ │ │ │ └── fuzztests.cpp
│ │ │ ├── relacy/
│ │ │ │ ├── freelist.cpp
│ │ │ │ ├── integrated.cpp
│ │ │ │ ├── relacy/
│ │ │ │ │ ├── CHANGES
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── VERSION
│ │ │ │ │ ├── example/
│ │ │ │ │ │ ├── cli_ws_deque/
│ │ │ │ │ │ │ ├── cli_ws_deque.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── cli_ws_deque.sln
│ │ │ │ │ │ │ │ └── cli_ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── condvar/
│ │ │ │ │ │ │ ├── condvar.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── condvar.sln
│ │ │ │ │ │ │ │ └── condvar.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── condvar.sln
│ │ │ │ │ │ │ │ └── condvar.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── eao_blocking/
│ │ │ │ │ │ │ └── eao_blocking.cpp
│ │ │ │ │ │ ├── eventcount/
│ │ │ │ │ │ │ ├── eventcount.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── examples/
│ │ │ │ │ │ │ ├── amp_condvar.hpp
│ │ │ │ │ │ │ ├── examples.cpp
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── examples.sln
│ │ │ │ │ │ │ │ └── examples.vcproj
│ │ │ │ │ │ │ ├── spsc_overwrite_queue.hpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── java_ws_deque/
│ │ │ │ │ │ │ ├── java_ws_deque.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── java_ws_deque.sln
│ │ │ │ │ │ │ │ └── java_ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── mpmc/
│ │ │ │ │ │ │ ├── mpmc.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── mpmc.sln
│ │ │ │ │ │ │ │ └── mpmc.vcproj
│ │ │ │ │ │ │ ├── pcx.h
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── mutex_business_logic/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── mutex_business_logic.sln
│ │ │ │ │ │ │ │ └── mutex_business_logic.vcproj
│ │ │ │ │ │ │ ├── mutex_business_logic.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── peterson/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── peterson.sln
│ │ │ │ │ │ │ │ └── peterson.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── peterson.sln
│ │ │ │ │ │ │ │ └── peterson.vcproj
│ │ │ │ │ │ │ ├── peterson.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── proxy_collector/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ │ │ │ ├── proxy_collector.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── ref_counting/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ │ │ │ ├── ref_counting.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── smr/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── smr.sln
│ │ │ │ │ │ │ │ └── smr.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── smr.sln
│ │ │ │ │ │ │ │ └── smr.vcproj
│ │ │ │ │ │ │ ├── smr.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── spsc_queue/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ │ │ │ ├── spsc_queue.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── stack/
│ │ │ │ │ │ │ ├── DESCRIPTION.TXT
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── stack.sln
│ │ │ │ │ │ │ │ └── stack.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── stack.sln
│ │ │ │ │ │ │ │ └── stack.vcproj
│ │ │ │ │ │ │ ├── stack.cpp
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── tbb_eventcount/
│ │ │ │ │ │ │ ├── eventcount.cpp
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ │ │ │ └── eventcount.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ │ ├── ws_deque/
│ │ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ │ ├── stdafx.h
│ │ │ │ │ │ │ └── ws_deque.cpp
│ │ │ │ │ │ └── ws_deque2/
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ ├── stdafx.h
│ │ │ │ │ │ └── ws_deque.cpp
│ │ │ │ │ ├── relacy/
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── atomic_events.hpp
│ │ │ │ │ │ ├── atomic_fence.hpp
│ │ │ │ │ │ ├── backoff.hpp
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ ├── cli.hpp
│ │ │ │ │ │ ├── cli_interlocked.hpp
│ │ │ │ │ │ ├── cli_var.hpp
│ │ │ │ │ │ ├── cli_volatile.hpp
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── context_addr_hash.hpp
│ │ │ │ │ │ ├── context_base.hpp
│ │ │ │ │ │ ├── context_base_impl.hpp
│ │ │ │ │ │ ├── context_bound_scheduler.hpp
│ │ │ │ │ │ ├── defs.hpp
│ │ │ │ │ │ ├── dyn_thread.hpp
│ │ │ │ │ │ ├── dyn_thread_ctx.hpp
│ │ │ │ │ │ ├── foreach.hpp
│ │ │ │ │ │ ├── full_search_scheduler.hpp
│ │ │ │ │ │ ├── history.hpp
│ │ │ │ │ │ ├── java.hpp
│ │ │ │ │ │ ├── java_atomic.hpp
│ │ │ │ │ │ ├── java_var.hpp
│ │ │ │ │ │ ├── java_volatile.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ │ ├── pch.hpp
│ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ ├── pthread.h
│ │ │ │ │ │ ├── random.hpp
│ │ │ │ │ │ ├── random_scheduler.hpp
│ │ │ │ │ │ ├── relacy.hpp
│ │ │ │ │ │ ├── relacy_cli.hpp
│ │ │ │ │ │ ├── relacy_java.hpp
│ │ │ │ │ │ ├── relacy_std.hpp
│ │ │ │ │ │ ├── rmw.hpp
│ │ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ │ ├── signature.hpp
│ │ │ │ │ │ ├── slab_allocator.hpp
│ │ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ │ ├── pthread.hpp
│ │ │ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ │ │ └── windows.hpp
│ │ │ │ │ │ ├── sync_var.hpp
│ │ │ │ │ │ ├── test_params.hpp
│ │ │ │ │ │ ├── test_result.hpp
│ │ │ │ │ │ ├── test_suite.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_base.hpp
│ │ │ │ │ │ ├── thread_local.hpp
│ │ │ │ │ │ ├── thread_local_ctx.hpp
│ │ │ │ │ │ ├── var.hpp
│ │ │ │ │ │ ├── volatile.hpp
│ │ │ │ │ │ ├── waitset.hpp
│ │ │ │ │ │ └── windows.h
│ │ │ │ │ └── test/
│ │ │ │ │ ├── addr_hash.hpp
│ │ │ │ │ ├── advanced.txt
│ │ │ │ │ ├── compare_swap.hpp
│ │ │ │ │ ├── condvar.hpp
│ │ │ │ │ ├── data_race.hpp
│ │ │ │ │ ├── detection.txt
│ │ │ │ │ ├── dyn_thread.hpp
│ │ │ │ │ ├── event.hpp
│ │ │ │ │ ├── features.txt
│ │ │ │ │ ├── fence.hpp
│ │ │ │ │ ├── foo.cpp
│ │ │ │ │ ├── futex.hpp
│ │ │ │ │ ├── g++/
│ │ │ │ │ │ ├── build_all_cygwin_debug.bat
│ │ │ │ │ │ ├── build_all_debug.bat
│ │ │ │ │ │ ├── build_all_release.sh
│ │ │ │ │ │ ├── build_cygwin_release.cmd
│ │ │ │ │ │ ├── build_debug.cmd
│ │ │ │ │ │ ├── build_release.cmd
│ │ │ │ │ │ └── test.cpp
│ │ │ │ │ ├── jtest/
│ │ │ │ │ │ ├── jtest.cpp
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── jtest.sln
│ │ │ │ │ │ │ └── jtest.vcproj
│ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ ├── jtest.sln
│ │ │ │ │ │ │ └── jtest.vcproj
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ ├── main.cpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ ├── memory_order.hpp
│ │ │ │ │ ├── msvc71/
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ ├── rrd.sln
│ │ │ │ │ │ ├── rrd.vcproj
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ ├── rrd.sln
│ │ │ │ │ │ ├── rrd.vcproj
│ │ │ │ │ │ ├── test.sln
│ │ │ │ │ │ └── test.vcproj
│ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ ├── ntest/
│ │ │ │ │ │ ├── msvc8/
│ │ │ │ │ │ │ ├── ntest.sln
│ │ │ │ │ │ │ └── ntest.vcproj
│ │ │ │ │ │ ├── msvc9/
│ │ │ │ │ │ │ ├── ntest.sln
│ │ │ │ │ │ │ └── ntest.vcproj
│ │ │ │ │ │ ├── ntest.cpp
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ ├── pthread.hpp
│ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ ├── stdafx.h
│ │ │ │ │ ├── thread_local.hpp
│ │ │ │ │ ├── todo.txt
│ │ │ │ │ ├── trash/
│ │ │ │ │ │ ├── original.hpp
│ │ │ │ │ │ └── rtl.hpp
│ │ │ │ │ ├── tutorial.txt
│ │ │ │ │ ├── wfmo.hpp
│ │ │ │ │ └── windows.hpp
│ │ │ │ ├── relacy_shims.h
│ │ │ │ └── spmchash.cpp
│ │ │ └── unittests/
│ │ │ ├── mallocmacro.cpp
│ │ │ ├── minitest.h
│ │ │ └── unittests.cpp
│ │ ├── fmt/
│ │ │ ├── .clang-format
│ │ │ ├── .github/
│ │ │ │ └── pull_request_template.md
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── ChangeLog.rst
│ │ │ ├── LICENSE.rst
│ │ │ ├── README.rst
│ │ │ ├── include/
│ │ │ │ └── fmt/
│ │ │ │ ├── chrono.h
│ │ │ │ ├── color.h
│ │ │ │ ├── core.h
│ │ │ │ ├── format-inl.h
│ │ │ │ ├── format.h
│ │ │ │ ├── locale.h
│ │ │ │ ├── ostream.h
│ │ │ │ ├── posix.h
│ │ │ │ ├── prepare.h
│ │ │ │ ├── printf.h
│ │ │ │ ├── ranges.h
│ │ │ │ └── safe-duration-cast.h
│ │ │ ├── src/
│ │ │ │ ├── format.cc
│ │ │ │ └── posix.cc
│ │ │ └── support/
│ │ │ └── cmake/
│ │ │ ├── FindSetEnv.cmake
│ │ │ ├── cxx14.cmake
│ │ │ ├── fmt-config.cmake.in
│ │ │ └── fmt.pc.in
│ │ ├── pybind11/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .readthedocs.yml
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── ISSUE_TEMPLATE.md
│ │ │ ├── LICENSE
│ │ │ ├── MANIFEST.in
│ │ │ ├── README.md
│ │ │ ├── docs/
│ │ │ │ ├── Doxyfile
│ │ │ │ ├── _static/
│ │ │ │ │ └── theme_overrides.css
│ │ │ │ ├── advanced/
│ │ │ │ │ ├── cast/
│ │ │ │ │ │ ├── chrono.rst
│ │ │ │ │ │ ├── custom.rst
│ │ │ │ │ │ ├── eigen.rst
│ │ │ │ │ │ ├── functional.rst
│ │ │ │ │ │ ├── index.rst
│ │ │ │ │ │ ├── overview.rst
│ │ │ │ │ │ ├── stl.rst
│ │ │ │ │ │ └── strings.rst
│ │ │ │ │ ├── classes.rst
│ │ │ │ │ ├── embedding.rst
│ │ │ │ │ ├── exceptions.rst
│ │ │ │ │ ├── functions.rst
│ │ │ │ │ ├── misc.rst
│ │ │ │ │ ├── pycpp/
│ │ │ │ │ │ ├── index.rst
│ │ │ │ │ │ ├── numpy.rst
│ │ │ │ │ │ ├── object.rst
│ │ │ │ │ │ └── utilities.rst
│ │ │ │ │ └── smart_ptrs.rst
│ │ │ │ ├── basics.rst
│ │ │ │ ├── benchmark.py
│ │ │ │ ├── benchmark.rst
│ │ │ │ ├── changelog.rst
│ │ │ │ ├── classes.rst
│ │ │ │ ├── compiling.rst
│ │ │ │ ├── conf.py
│ │ │ │ ├── faq.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── intro.rst
│ │ │ │ ├── limitations.rst
│ │ │ │ ├── reference.rst
│ │ │ │ ├── release.rst
│ │ │ │ ├── requirements.txt
│ │ │ │ └── upgrade.rst
│ │ │ ├── include/
│ │ │ │ └── pybind11/
│ │ │ │ ├── attr.h
│ │ │ │ ├── buffer_info.h
│ │ │ │ ├── cast.h
│ │ │ │ ├── chrono.h
│ │ │ │ ├── common.h
│ │ │ │ ├── complex.h
│ │ │ │ ├── detail/
│ │ │ │ │ ├── class.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── descr.h
│ │ │ │ │ ├── init.h
│ │ │ │ │ ├── internals.h
│ │ │ │ │ └── typeid.h
│ │ │ │ ├── eigen.h
│ │ │ │ ├── embed.h
│ │ │ │ ├── eval.h
│ │ │ │ ├── functional.h
│ │ │ │ ├── iostream.h
│ │ │ │ ├── numpy.h
│ │ │ │ ├── operators.h
│ │ │ │ ├── options.h
│ │ │ │ ├── pybind11.h
│ │ │ │ ├── pytypes.h
│ │ │ │ ├── stl.h
│ │ │ │ └── stl_bind.h
│ │ │ ├── pybind11/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── __main__.py
│ │ │ │ └── _version.py
│ │ │ ├── setup.cfg
│ │ │ ├── setup.py
│ │ │ ├── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── conftest.py
│ │ │ │ ├── constructor_stats.h
│ │ │ │ ├── local_bindings.h
│ │ │ │ ├── object.h
│ │ │ │ ├── pybind11_cross_module_tests.cpp
│ │ │ │ ├── pybind11_tests.cpp
│ │ │ │ ├── pybind11_tests.h
│ │ │ │ ├── pytest.ini
│ │ │ │ ├── test_buffers.cpp
│ │ │ │ ├── test_buffers.py
│ │ │ │ ├── test_builtin_casters.cpp
│ │ │ │ ├── test_builtin_casters.py
│ │ │ │ ├── test_call_policies.cpp
│ │ │ │ ├── test_call_policies.py
│ │ │ │ ├── test_callbacks.cpp
│ │ │ │ ├── test_callbacks.py
│ │ │ │ ├── test_chrono.cpp
│ │ │ │ ├── test_chrono.py
│ │ │ │ ├── test_class.cpp
│ │ │ │ ├── test_class.py
│ │ │ │ ├── test_cmake_build/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── embed.cpp
│ │ │ │ │ ├── installed_embed/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── installed_function/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── installed_target/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── main.cpp
│ │ │ │ │ ├── subdirectory_embed/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── subdirectory_function/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ ├── subdirectory_target/
│ │ │ │ │ │ └── CMakeLists.txt
│ │ │ │ │ └── test.py
│ │ │ │ ├── test_constants_and_functions.cpp
│ │ │ │ ├── test_constants_and_functions.py
│ │ │ │ ├── test_copy_move.cpp
│ │ │ │ ├── test_copy_move.py
│ │ │ │ ├── test_docstring_options.cpp
│ │ │ │ ├── test_docstring_options.py
│ │ │ │ ├── test_eigen.cpp
│ │ │ │ ├── test_eigen.py
│ │ │ │ ├── test_embed/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── catch.cpp
│ │ │ │ │ ├── external_module.cpp
│ │ │ │ │ ├── test_interpreter.cpp
│ │ │ │ │ └── test_interpreter.py
│ │ │ │ ├── test_enum.cpp
│ │ │ │ ├── test_enum.py
│ │ │ │ ├── test_eval.cpp
│ │ │ │ ├── test_eval.py
│ │ │ │ ├── test_eval_call.py
│ │ │ │ ├── test_exceptions.cpp
│ │ │ │ ├── test_exceptions.py
│ │ │ │ ├── test_factory_constructors.cpp
│ │ │ │ ├── test_factory_constructors.py
│ │ │ │ ├── test_gil_scoped.cpp
│ │ │ │ ├── test_gil_scoped.py
│ │ │ │ ├── test_iostream.cpp
│ │ │ │ ├── test_iostream.py
│ │ │ │ ├── test_kwargs_and_defaults.cpp
│ │ │ │ ├── test_kwargs_and_defaults.py
│ │ │ │ ├── test_local_bindings.cpp
│ │ │ │ ├── test_local_bindings.py
│ │ │ │ ├── test_methods_and_attributes.cpp
│ │ │ │ ├── test_methods_and_attributes.py
│ │ │ │ ├── test_modules.cpp
│ │ │ │ ├── test_modules.py
│ │ │ │ ├── test_multiple_inheritance.cpp
│ │ │ │ ├── test_multiple_inheritance.py
│ │ │ │ ├── test_numpy_array.cpp
│ │ │ │ ├── test_numpy_array.py
│ │ │ │ ├── test_numpy_dtypes.cpp
│ │ │ │ ├── test_numpy_dtypes.py
│ │ │ │ ├── test_numpy_vectorize.cpp
│ │ │ │ ├── test_numpy_vectorize.py
│ │ │ │ ├── test_opaque_types.cpp
│ │ │ │ ├── test_opaque_types.py
│ │ │ │ ├── test_operator_overloading.cpp
│ │ │ │ ├── test_operator_overloading.py
│ │ │ │ ├── test_pickling.cpp
│ │ │ │ ├── test_pickling.py
│ │ │ │ ├── test_pytypes.cpp
│ │ │ │ ├── test_pytypes.py
│ │ │ │ ├── test_sequences_and_iterators.cpp
│ │ │ │ ├── test_sequences_and_iterators.py
│ │ │ │ ├── test_smart_ptr.cpp
│ │ │ │ ├── test_smart_ptr.py
│ │ │ │ ├── test_stl.cpp
│ │ │ │ ├── test_stl.py
│ │ │ │ ├── test_stl_binders.cpp
│ │ │ │ ├── test_stl_binders.py
│ │ │ │ ├── test_tagbased_polymorphic.cpp
│ │ │ │ ├── test_tagbased_polymorphic.py
│ │ │ │ ├── test_virtual_functions.cpp
│ │ │ │ └── test_virtual_functions.py
│ │ │ └── tools/
│ │ │ ├── FindCatch.cmake
│ │ │ ├── FindEigen3.cmake
│ │ │ ├── FindPythonLibsNew.cmake
│ │ │ ├── check-style.sh
│ │ │ ├── libsize.py
│ │ │ ├── mkdoc.py
│ │ │ ├── pybind11Config.cmake.in
│ │ │ └── pybind11Tools.cmake
│ │ └── zstd/
│ │ └── lib/
│ │ ├── README.md
│ │ ├── common/
│ │ │ ├── bitstream.h
│ │ │ ├── compiler.h
│ │ │ ├── cpu.h
│ │ │ ├── debug.c
│ │ │ ├── debug.h
│ │ │ ├── entropy_common.c
│ │ │ ├── error_private.c
│ │ │ ├── error_private.h
│ │ │ ├── fse.h
│ │ │ ├── fse_decompress.c
│ │ │ ├── huf.h
│ │ │ ├── mem.h
│ │ │ ├── pool.c
│ │ │ ├── pool.h
│ │ │ ├── threading.c
│ │ │ ├── threading.h
│ │ │ ├── xxhash.c
│ │ │ ├── xxhash.h
│ │ │ ├── zstd_common.c
│ │ │ ├── zstd_errors.h
│ │ │ └── zstd_internal.h
│ │ ├── compress/
│ │ │ ├── fse_compress.c
│ │ │ ├── hist.c
│ │ │ ├── hist.h
│ │ │ ├── huf_compress.c
│ │ │ ├── zstd_compress.c
│ │ │ ├── zstd_compress_internal.h
│ │ │ ├── zstd_compress_literals.c
│ │ │ ├── zstd_compress_literals.h
│ │ │ ├── zstd_compress_sequences.c
│ │ │ ├── zstd_compress_sequences.h
│ │ │ ├── zstd_compress_superblock.c
│ │ │ ├── zstd_compress_superblock.h
│ │ │ ├── zstd_cwksp.h
│ │ │ ├── zstd_double_fast.c
│ │ │ ├── zstd_double_fast.h
│ │ │ ├── zstd_fast.c
│ │ │ ├── zstd_fast.h
│ │ │ ├── zstd_lazy.c
│ │ │ ├── zstd_lazy.h
│ │ │ ├── zstd_ldm.c
│ │ │ ├── zstd_ldm.h
│ │ │ ├── zstd_opt.c
│ │ │ ├── zstd_opt.h
│ │ │ ├── zstdmt_compress.c
│ │ │ └── zstdmt_compress.h
│ │ ├── decompress/
│ │ │ ├── huf_decompress.c
│ │ │ ├── zstd_ddict.c
│ │ │ ├── zstd_ddict.h
│ │ │ ├── zstd_decompress.c
│ │ │ ├── zstd_decompress_block.c
│ │ │ ├── zstd_decompress_block.h
│ │ │ └── zstd_decompress_internal.h
│ │ ├── deprecated/
│ │ │ ├── zbuff.h
│ │ │ ├── zbuff_common.c
│ │ │ ├── zbuff_compress.c
│ │ │ └── zbuff_decompress.c
│ │ ├── dictBuilder/
│ │ │ ├── cover.c
│ │ │ ├── cover.h
│ │ │ ├── divsufsort.c
│ │ │ ├── divsufsort.h
│ │ │ ├── fastcover.c
│ │ │ ├── zdict.c
│ │ │ └── zdict.h
│ │ ├── dll/
│ │ │ └── example/
│ │ │ ├── README.md
│ │ │ ├── build_package.bat
│ │ │ ├── fullbench-dll.sln
│ │ │ └── fullbench-dll.vcxproj
│ │ ├── legacy/
│ │ │ ├── zstd_legacy.h
│ │ │ ├── zstd_v01.c
│ │ │ ├── zstd_v01.h
│ │ │ ├── zstd_v02.c
│ │ │ ├── zstd_v02.h
│ │ │ ├── zstd_v03.c
│ │ │ ├── zstd_v03.h
│ │ │ ├── zstd_v04.c
│ │ │ ├── zstd_v04.h
│ │ │ ├── zstd_v05.c
│ │ │ ├── zstd_v05.h
│ │ │ ├── zstd_v06.c
│ │ │ ├── zstd_v06.h
│ │ │ ├── zstd_v07.c
│ │ │ └── zstd_v07.h
│ │ ├── libzstd.pc.in
│ │ └── zstd.h
│ └── tube/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── pytube/
│ │ ├── __init__.py
│ │ ├── data_channel_manager.py
│ │ ├── test_dc_manager.py
│ │ └── utils.py
│ └── src_cpp/
│ ├── context.h
│ ├── data_block.h
│ ├── data_channel.cc
│ ├── data_channel.h
│ ├── dispatcher.h
│ ├── env_thread.h
│ ├── episodic_trajectory.h
│ ├── fixed_len_trajectory.h
│ ├── indefinite_trajectory.h
│ ├── pybind.cc
│ ├── test/
│ │ ├── test_data_channel.cc
│ │ └── test_producer.h
│ └── utils.h
└── tests/
├── CMakeLists.txt
├── README.md
├── connectfour-tests.cc
├── havannah-state-tests.cc
├── havannah-tests.cc
├── hex-state-tests.cc
├── hex-tests.cc
├── ludii-game-tests.cc
├── python/
│ └── test_replay_buffer.py
├── tests.cc
└── utils.h
Showing preview only (4,356K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (26049 symbols across 1783 files)
FILE: littlegolem/play_littlegolem.py
function lg_connect (line 13) | def lg_connect(thelogin, thepassword):
function lg_clean_str (line 23) | def lg_clean_str(thestr):
function lg_get_onmove_games (line 27) | def lg_get_onmove_games(thecookies):
function lg_get_hsgf (line 41) | def lg_get_hsgf(thegid):
function lg_play (line 50) | def lg_play(thecookies, thegid, themove):
function einstein_convert_txt_to_polygames (line 56) | def einstein_convert_txt_to_polygames(myhsgf, gid):
function breakthrough_convert_txt_to_polygames (line 114) | def breakthrough_convert_txt_to_polygames(txt):
function hex_convert_hsgf_to_polygames (line 157) | def hex_convert_hsgf_to_polygames(hsgf):
function havannah_convert_hsgf_to_polygames (line 197) | def havannah_convert_hsgf_to_polygames(hsgf, boardsize):
FILE: pypolygames/__main__.py
function _check_arg_consistency (line 50) | def _check_arg_consistency(args: argparse.Namespace) -> None:
function parse_args (line 91) | def parse_args() -> argparse.Namespace:
function _get_game_features (line 293) | def _get_game_features(game_params: GameParams) -> str:
function _get_timestamp (line 297) | def _get_timestamp() -> str:
function update_and_create_checkpoint_dir (line 301) | def update_and_create_checkpoint_dir(
function instanciate_params_from_args (line 317) | def instanciate_params_from_args(
function run_training_from_args (line 327) | def run_training_from_args(args: argparse.Namespace):
function run_evaluation_from_args (line 350) | def run_evaluation_from_args(args: argparse.Namespace):
function run_training_and_evaluation_from_args (line 356) | def run_training_and_evaluation_from_args(args: argparse.Namespace):
function run_human_played_game_from_args (line 395) | def run_human_played_game_from_args(args: argparse.Namespace):
function run_tp_played_game_from_args (line 409) | def run_tp_played_game_from_args(args: argparse.Namespace):
function convert_checkpoint_from_args (line 422) | def convert_checkpoint_from_args(args: argparse.Namespace):
function draw_model_from_args (line 438) | def draw_model_from_args(args: argparse.Namespace):
function run_training_and_evaluation_from_args_warning (line 448) | def run_training_and_evaluation_from_args_warning(args: argparse.Namespa...
FILE: pypolygames/convert.py
function convert_checkpoint (line 26) | def convert_checkpoint(
FILE: pypolygames/draw_model.py
function draw_model (line 21) | def draw_model(
FILE: pypolygames/env_creation_helpers.py
function sanitize_game_params (line 18) | def sanitize_game_params(game_params: GameParams) -> None:
function create_game (line 32) | def create_game(
function create_model (line 70) | def create_model(
function _set_mcts_option (line 103) | def _set_mcts_option(
function _create_pure_mcts_player (line 127) | def _create_pure_mcts_player(
function _create_neural_mcts_player (line 140) | def _create_neural_mcts_player(
function _create_forward_player (line 168) | def _create_forward_player(
function create_player (line 193) | def create_player(
FILE: pypolygames/evaluation.py
function create_plotter (line 32) | def create_plotter(eval_params: EvalParams) -> utils.Plotter:
function create_checkpoint_iter (line 50) | def create_checkpoint_iter(eval_params: EvalParams, only_last: bool = Fa...
function create_models_and_devices_opponent (line 66) | def create_models_and_devices_opponent(
function create_evaluation_environment (line 101) | def create_evaluation_environment(
function player_moves_first (line 196) | def player_moves_first(game_id, num_games_eval):
function _forward_pass_on_device (line 204) | def _forward_pass_on_device(
function _play_game_neural_mcts_against_pure_mcts_opponent (line 213) | def _play_game_neural_mcts_against_pure_mcts_opponent(
function _play_game_neural_mcts_against_neural_mcts_opponent (line 250) | def _play_game_neural_mcts_against_neural_mcts_opponent(
function evaluate_on_checkpoint (line 318) | def evaluate_on_checkpoint(
function run_evaluation (line 379) | def run_evaluation(eval_params: EvalParams, execution_params: ExecutionP...
FILE: pypolygames/human.py
function create_human_environment (line 31) | def create_human_environment(
function create_tp_environment (line 102) | def create_tp_environment(
function _forward_pass_on_device (line 160) | def _forward_pass_on_device(
function _play_game_against_mcts (line 174) | def _play_game_against_mcts(context: tube.Context) -> None:
function _play_game_against_neural_mcts (line 180) | def _play_game_against_neural_mcts(
function play_game (line 234) | def play_game(
function play_tp_game (line 252) | def play_tp_game( #FIXME TODO not sure this helps
function run_human_played_game (line 275) | def run_human_played_game(
function run_tp_played_game (line 332) | def run_tp_played_game(
FILE: pypolygames/model_zoo/amazons_model.py
class AmazonsModel (line 15) | class AmazonsModel(torch.jit.ScriptModule):
method __init__ (line 26) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 93) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 129) | def forward(self, x: torch.Tensor):
method loss (line 135) | def loss(
FILE: pypolygames/model_zoo/connect4_benchmark_model.py
class Connect4BenchModel (line 14) | class Connect4BenchModel(torch.jit.ScriptModule):
method __init__ (line 15) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 25) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 40) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/deep_conv_conv_logit_model.py
class DeepConvConvLogitModel (line 16) | class DeepConvConvLogitModel(torch.jit.ScriptModule):
method __init__ (line 30) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 134) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 149) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/deep_conv_fc_logit_model.py
class DeepConvFCLogitModel (line 16) | class DeepConvFCLogitModel(torch.jit.ScriptModule):
method __init__ (line 30) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 126) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 141) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/generic_model.py
class GenericModel (line 16) | class GenericModel(torch.jit.ScriptModule):
method __init__ (line 41) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 167) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 185) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/loss.py
function mcts_loss (line 7) | def mcts_loss(
FILE: pypolygames/model_zoo/nano_conv_logit_model.py
class NanoConvLogitModel (line 16) | class NanoConvLogitModel(torch.jit.ScriptModule):
method __init__ (line 28) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 93) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 104) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/nano_fc_logit_model.py
class NanoFCLogitModel (line 16) | class NanoFCLogitModel(torch.jit.ScriptModule):
method __init__ (line 28) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 85) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 96) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/res_conv_conv_logit_model.py
class ResConvConvLogitModel (line 16) | class ResConvConvLogitModel(torch.jit.ScriptModule):
method __init__ (line 38) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 162) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 184) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/res_conv_conv_logit_pool_model.py
class ResConvConvLogitPoolModel (line 16) | class ResConvConvLogitPoolModel(torch.jit.ScriptModule):
method __init__ (line 38) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 164) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 187) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/res_conv_conv_logit_pool_model_v2.py
class ResConvConvLogitPoolModelV2 (line 18) | class ResConvConvLogitPoolModelV2(torch.jit.ScriptModule):
method __init__ (line 41) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 185) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 219) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/res_conv_fc_logit_model.py
class ResConvFCLogitModel (line 16) | class ResConvFCLogitModel(torch.jit.ScriptModule):
method __init__ (line 38) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 154) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 176) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/u_conv_conv_logit_model.py
class UConvConvLogitModel (line 16) | class UConvConvLogitModel(torch.jit.ScriptModule):
method __init__ (line 39) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 220) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 248) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/u_conv_fc_logit_model.py
class UConvFCLogitModel (line 16) | class UConvFCLogitModel(torch.jit.ScriptModule):
method __init__ (line 39) | def __init__(self, game_params: GameParams, model_params: ModelParams):
method _forward (line 212) | def _forward(self, x: torch.Tensor, return_logit: bool):
method forward (line 240) | def forward(self, x: torch.Tensor):
FILE: pypolygames/model_zoo/utils.py
function register_model (line 16) | def register_model(cls):
function get_game_info (line 21) | def get_game_info(game_params: params) -> Dict[str, list]:
function get_consistent_padding_from_nnks (line 34) | def get_consistent_padding_from_nnks(nnks: int, dilation: int = 1) -> int:
FILE: pypolygames/params.py
function boolarg (line 14) | def boolarg(x):
class ArgFields (line 22) | class ArgFields:
class GameParams (line 28) | class GameParams:
method __setattr__ (line 42) | def __setattr__(self, attr, value):
method __eq__ (line 47) | def __eq__(self, other_game_params):
method arg_fields (line 66) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
class ModelParams (line 160) | class ModelParams:
method __setattr__ (line 181) | def __setattr__(self, attr, value):
method __post_init__ (line 186) | def __post_init__(self):
method arg_fields (line 200) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
class OptimParams (line 320) | class OptimParams:
method __setattr__ (line 329) | def __setattr__(self, attr, value):
method arg_fields (line 335) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
class SimulationParams (line 378) | class SimulationParams:
method __setattr__ (line 397) | def __setattr__(self, attr, value):
method __post_init__ (line 402) | def __post_init__(self) -> None:
method arg_fields (line 407) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
class ExecutionParams (line 526) | class ExecutionParams:
method __setattr__ (line 544) | def __setattr__(self, attr, value):
method __post_init__ (line 552) | def __post_init__(self) -> None:
method arg_fields (line 561) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
class EvalParams (line 673) | class EvalParams:
method __setattr__ (line 692) | def __setattr__(self, attr, value):
method __post_init__ (line 704) | def __post_init__(self) -> None:
method arg_fields (line 731) | def arg_fields(cls) -> Iterator[Tuple[str, ArgFields]]:
FILE: pypolygames/tests/test_interactions.py
class FileStream (line 17) | class FileStream:
method __init__ (line 21) | def __init__(self) -> None:
method __del__ (line 27) | def __del__(self) -> None:
function test_game_interactions (line 51) | def test_game_interactions(game_name: str):
FILE: pypolygames/tests/test_mcts.py
function test_mcts (line 19) | def test_mcts(game_name) -> None:
FILE: pypolygames/tests/test_params.py
function test_dataclass (line 23) | def test_dataclass(cls):
FILE: pypolygames/tests/test_zoo.py
function test_models (line 16) | def test_models(model_name) -> None:
FILE: pypolygames/training.py
function create_optimizer (line 40) | def create_optimizer(
function create_training_environment (line 61) | def create_training_environment(
function warm_up_replay_buffer (line 238) | def warm_up_replay_buffer(
class ModelWrapperForDDP (line 279) | class ModelWrapperForDDP(nn.Module):
method __init__ (line 280) | def __init__(self, module):
method forward (line 283) | def forward(self, x: torch.Tensor, rnn_state: torch.Tensor=None, rnn_s...
class DDPWrapperForModel (line 289) | class DDPWrapperForModel(nn.Module):
method __init__ (line 290) | def __init__(self, module):
method _forward (line 293) | def _forward(self, x: torch.Tensor, rnn_state: torch.Tensor=None, rnn_...
function _train_epoch (line 306) | def _train_epoch(
function train_model (line 457) | def train_model(
function client_loop (line 578) | def client_loop(
function run_training (line 598) | def run_training(
FILE: pypolygames/utils/assert_utils.py
function assert_eq (line 9) | def assert_eq(real, expected):
function assert_neq (line 13) | def assert_neq(real, expected):
function assert_lt (line 17) | def assert_lt(real, expected):
function assert_lteq (line 21) | def assert_lteq(real, expected):
function assert_tensor_eq (line 25) | def assert_tensor_eq(t1, t2, eps=1e-6):
function assert_zero_grads (line 40) | def assert_zero_grads(params):
FILE: pypolygames/utils/checkpoint.py
function save_checkpoint (line 42) | def save_checkpoint(
function load_checkpoint (line 87) | def load_checkpoint(checkpoint_path: Path) -> Checkpoint:
function gen_checkpoints (line 110) | def gen_checkpoints(
FILE: pypolygames/utils/command_history.py
class CommandHistory (line 14) | class CommandHistory:
method __init__ (line 15) | def __init__(self):
method build_history (line 25) | def build_history(self, former_command_history: "CommandHistory"):
method former_commands_contain (line 28) | def former_commands_contain(self, option: str) -> bool:
method last_command_contains (line 36) | def last_command_contains(self, option: str) -> bool:
method last_command_contains_params (line 44) | def last_command_contains_params(
method update_params_from_checkpoint (line 60) | def update_params_from_checkpoint(
FILE: pypolygames/utils/helpers.py
function generate_random_seeds (line 13) | def generate_random_seeds(seed: int) -> Iterator[int]:
function to_device (line 25) | def to_device(batch, device):
FILE: pypolygames/utils/listings.py
function games (line 11) | def games(olympiads: bool = False) -> tp.List[str]:
FILE: pypolygames/utils/logger.py
class Logger (line 10) | class Logger:
method __init__ (line 11) | def __init__(self, path, mode='w'):
method write (line 21) | def write(self, message):
method flush (line 26) | def flush(self):
FILE: pypolygames/utils/multi_counter.py
class ValueStats (line 13) | class ValueStats:
method __init__ (line 14) | def __init__(self, name=None):
method feed (line 18) | def feed(self, v):
method mean (line 29) | def mean(self):
method summary (line 32) | def summary(self, info=None):
method reset (line 52) | def reset(self):
class MultiCounter (line 61) | class MultiCounter:
method __init__ (line 62) | def __init__(self, root: Path, verbose=False):
method __getitem__ (line 75) | def __getitem__(self, key):
method start_timer (line 84) | def start_timer(self):
method inc (line 87) | def inc(self, key):
method reset (line 95) | def reset(self):
method summary (line 103) | def summary(self, global_counter):
FILE: pypolygames/utils/plotter.py
class Plotter (line 13) | class Plotter:
method __init__ (line 14) | def __init__(self, plot_enabled: bool, env: str, server: str, port: int):
method plot_results (line 22) | def plot_results(self, results: List[Tuple[int, Result]]):
method save (line 92) | def save(self):
FILE: pypolygames/utils/restrack.py
function get_gpu_usage_nvidia (line 11) | def get_gpu_usage_nvidia():
function get_res_usage_psutil_str (line 38) | def get_res_usage_psutil_str():
function get_res_usage_no_psutil_str (line 63) | def get_res_usage_no_psutil_str():
function get_res_usage_str (line 73) | def get_res_usage_str():
FILE: pypolygames/utils/result.py
function parse_reward (line 9) | def parse_reward(reward):
class Result (line 23) | class Result:
method __init__ (line 24) | def __init__(self, reward):
method log (line 28) | def log(self):
FILE: pypolygames/utils/test_listings.py
function test_lists (line 10) | def test_lists() -> None:
FILE: pypolygames/weight_init.py
function _init_weight_from_method (line 11) | def _init_weight_from_method(init_method):
FILE: src/common/async.h
function namespace (line 16) | namespace async {
function try (line 119) | try {
function setPriority (line 168) | void setPriority(int value) {
type Thread (line 178) | struct Thread {
function enqueue (line 234) | void enqueue(Function* func) {
function getThread (line 255) | struct Threads {
function enqueue (line 268) | void enqueue(const Handle& h) {
function start (line 277) | void start(int nThreads) {
function enqueue (line 325) | void enqueue(const Handle& h) {
function wait (line 330) | void wait() {
FILE: src/common/thread_id.cc
type common (line 9) | namespace common {
function getThreadId (line 11) | int getThreadId() {
FILE: src/common/thread_id.h
function namespace (line 2) | namespace common {
FILE: src/common/threads.cc
type threads (line 4) | namespace threads {
function init (line 9) | void init(int nThreads) {
function setCurrentThreadName (line 44) | void setCurrentThreadName(const std::string& name) {
FILE: src/common/threads.h
function namespace (line 6) | namespace threads {
FILE: src/core/actor.h
function class (line 21) | class PiVal {
function class (line 40) | class Actor {
function allocBatch (line 155) | auto allocBatch = [&](auto&& sizes) {
function recordMove (line 234) | void recordMove(const core::State* state) {
FILE: src/core/actor_player.h
function namespace (line 6) | namespace core {
FILE: src/core/forward_player.h
function namespace (line 5) | namespace core {
FILE: src/core/game.cc
type core (line 16) | namespace core {
type BatchExecutor (line 18) | struct BatchExecutor {
type MoveHistory (line 20) | struct MoveHistory {
type Sequence (line 28) | struct Sequence {
type GameState (line 41) | struct GameState {
method randint (line 106) | int randint(int n) {
method cloneState (line 110) | std::unique_ptr<State> cloneState(const std::unique_ptr<State>& stat...
method doRandomMoves (line 114) | void doRandomMoves(GameState& gst, int n) {
method addGame (line 141) | std::list<GameState>::iterator addGame(std::list<GameState>::iterato...
method rewind (line 207) | bool rewind(GameState* s, int player, bool rewindToNegativeValue) co...
method actPrepareRnn (line 305) | void actPrepareRnn(GameState* gameState,
method actPrepareForward (line 324) | void actPrepareForward(GameState* gameState,
method actResult (line 335) | void actResult(GameState* gameState,
method prepareStateCallbacks (line 491) | void prepareStateCallbacks() {
method pushStateCallback (line 515) | void pushStateCallback(stateCallback cb) {
method runStateCallbacks (line 519) | void runStateCallbacks() {
method actForPlayer (line 529) | void actForPlayer(size_t playerIndex) {
method run (line 720) | void run() {
FILE: src/core/game.h
function namespace (line 57) | namespace core {
FILE: src/core/human_player.h
function namespace (line 12) | namespace core {
FILE: src/core/model_manager.cc
type core (line 17) | namespace core {
function convertIValueToMap (line 19) | std::unordered_map<std::string, at::Tensor> convertIValueToMap(
FILE: src/core/model_manager.h
function namespace (line 18) | namespace core {
FILE: src/core/player.h
function namespace (line 13) | namespace core {
FILE: src/core/pybind.cc
function PYBIND11_MODULE (line 20) | PYBIND11_MODULE(polygames, m) {
FILE: src/core/replay_buffer.cc
type cctx (line 16) | struct cctx {
method cctx (line 18) | cctx() {
type dctx (line 29) | struct dctx {
method dctx (line 31) | dctx() {
type core (line 43) | namespace core {
FILE: src/core/replay_buffer.h
function namespace (line 17) | namespace core {
FILE: src/core/state.cc
type core (line 10) | namespace core {
FILE: src/core/state.h
function namespace (line 25) | namespace core {
function GameStatus (line 101) | enum class GameStatus {
function virtual (line 229) | virtual float getReward(int player) const {
function virtual (line 249) | virtual float getRandomRolloutReward(int player) const {
function forward (line 263) | void forward(const mcts::Action& action) {
function virtual (line 274) | virtual std::unique_ptr<State> clone_() const = 0;
function virtual (line 352) | virtual std::string actionDescription(const _Action& action) const {
function virtual (line 366) | virtual int parseAction(const std::string& str) const {
function virtual (line 422) | virtual int humanInputAction(
function undoLastMove (line 450) | void undoLastMove() {
function virtual (line 463) | virtual void setStateFromStr(const std::string& /*str*/) {
function printLastAction (line 466) | void printLastAction() {
function printLastActionXYZ (line 484) | void printLastActionXYZ() {
function undoLastMoveForPlayer (line 505) | void undoLastMoveForPlayer(int player) {
function DoRandomAction (line 536) | void DoRandomAction() {
function doIndexedAction (line 544) | void doIndexedAction(int j) {
function checkMove (line 550) | bool checkMove(const mcts::Action& c) const {
function GetFeatureLength (line 573) | int GetFeatureLength() const {
function reset (line 582) | void reset() {
function setFeatures (line 596) | void setFeatures(const FeatureOptions* opts) {
function copy (line 608) | void copy(const State& src) {
function addAction (line 627) | void addAction(int x, int y, int z) {
FILE: src/core/test_state.cc
function goodEval (line 12) | float goodEval(core::State& s) {
function randEval (line 32) | float randEval(core::State& s) {
function doSimpleTest (line 52) | int doSimpleTest(core::State& s) {
function doTest (line 118) | void doTest(core::State& s) {
function main (line 132) | int main() {
FILE: src/core/utils.h
function namespace (line 14) | namespace core {
function getPolicyMaskInTensor (line 62) | inline void getPolicyMaskInTensor(const State& state, torch::Tensor& mas...
function torch (line 68) | inline torch::Tensor getPolicyMaskInTensor(const State& state) {
function getPolicyInTensor (line 74) | inline void getPolicyInTensor(const State& state,
function getLegalPi (line 158) | inline void getLegalPi(const State& state,
function product (line 165) | inline int64_t product(const std::vector<int64_t>& nums) {
function softmax_ (line 173) | void softmax_(T begin, T end) {
function softmax_ (line 191) | inline static void softmax_(std::vector<float>& vec) {
function softmax_ (line 196) | void softmax_(T begin, T end, float temperature) {
function softmax_ (line 218) | inline static void softmax_(std::vector<float>& vec, float temperature) {
FILE: src/distributed/distributed.cc
type distributed (line 22) | namespace distributed {
type NetStats (line 24) | struct NetStats {
type NetStatsCounter (line 35) | struct NetStatsCounter {
function addnetworkstats (line 43) | void addnetworkstats(const T& obj, NetStatsCounter& counter) {
type RDMAModelInfo (line 108) | struct RDMAModelInfo {
type Crc32 (line 115) | struct Crc32 {
method Crc32 (line 117) | Crc32() {
class ServerImpl (line 137) | class ServerImpl {
method rollChance (line 143) | float rollChance(std::string_view id) {
method sampleModelId (line 172) | std::string_view sampleModelId() {
method addResult (line 207) | void addResult(std::string_view id, float ratio, float reward) {
method requestModel (line 303) | std::pair<std::string_view, int> requestModel(bool wantsNewModelId,
method requestStateDict (line 324) | std::optional<std::unordered_map<std::string, torch::Tensor>>
method requestCompressedStateDict (line 335) | std::optional<std::vector<char>> requestCompressedStateDict(
method trainData (line 395) | void trainData(const std::unordered_map<std::string, torch::Tensor> ...
method gameResult (line 399) | void gameResult(
type rdmaClient (line 410) | struct rdmaClient {
method rdmaConnect (line 422) | rdma::Endpoint rdmaConnect(rdma::Endpoint ep) {
method rdmaKeepalive (line 450) | bool rdmaKeepalive(rdma::Endpoint remoteEp) {
method rdmaGetModel (line 463) | std::optional<RDMAModelInfo> rdmaGetModel(rdma::Endpoint remoteEp,
type ModelInfo (line 567) | struct ModelInfo {
method define (line 608) | auto define(std::string name, R (ServerImpl::*f)(Args...)) {
method start (line 649) | void start(std::string_view endpoint) {
method updateModel (line 684) | void updateModel(const std::string& id,
class ClientImpl (line 705) | class ClientImpl {
type Bandit (line 738) | struct Bandit {
method sample (line 742) | float sample(std::string name, float weight = 1.0f) {
method get (line 747) | float get(std::string name) {
type BanditResultCounter (line 753) | struct BanditResultCounter {
method BanditResultCounter (line 757) | BanditResultCounter(Bandit& b, std::string name)
method success (line 761) | void success(bool succeeded = true) {
method createRdmaHost (line 773) | bool createRdmaHost() {
method requestModelStateDict (line 789) | void requestModelStateDict(std::string modelId, int modelVersion) {
method ClientImpl (line 924) | ClientImpl() {
method requestModel (line 939) | void requestModel(bool isTournamentOpponent) {
method connect (line 998) | void connect(std::string_view endpoint) {
method sendTrainData (line 1006) | void sendTrainData(
method sendResult (line 1031) | void sendResult(float reward,
method wantsTournamentResult (line 1047) | bool wantsTournamentResult() const {
method getModelId (line 1052) | std::string_view getModelId() const {
FILE: src/distributed/distributed.h
function namespace (line 15) | namespace rpc {
function namespace (line 109) | namespace distributed {
FILE: src/distributed/ib.cc
type ib (line 15) | namespace ib {
type Device (line 17) | struct Device {
type DeviceList (line 22) | struct DeviceList {
method DeviceList (line 27) | DeviceList() {
method size (line 43) | size_t size() const {
method begin (line 47) | auto begin() const {
method end (line 50) | auto end() const {
method empty (line 54) | bool empty() const {
class Error (line 63) | class Error : public rdma::Error {
function gidstr (line 68) | std::string gidstr(std::array<std::byte, 16> gid) {
type Port (line 77) | struct Port {
method lid (line 81) | uint32_t lid() {
method gid (line 84) | std::array<std::byte, 16> gid() {
type NoMove (line 94) | struct NoMove {
method NoMove (line 95) | NoMove() = default;
method NoMove (line 96) | NoMove(const NoMove&) = delete;
method NoMove (line 97) | NoMove(NoMove&&) = delete;
method NoMove (line 98) | NoMove& operator=(const NoMove&) = delete;
method NoMove (line 99) | NoMove& operator=(NoMove&&) = delete;
type Context (line 102) | struct Context : NoMove {
method Context (line 106) | Context(const Device& dev) {
type ProtectionDomain (line 131) | struct ProtectionDomain : NoMove {
method ProtectionDomain (line 133) | ProtectionDomain(Context& ctx) {
type MemoryRegion (line 147) | struct MemoryRegion : NoMove {
method MemoryRegion (line 149) | MemoryRegion(const ProtectionDomain& pd,
method lkey (line 164) | auto lkey() {
method rkey (line 167) | auto rkey() {
type CompletionQueue (line 172) | struct CompletionQueue : NoMove {
method CompletionQueue (line 174) | CompletionQueue(const Context& ctx, int size) {
method wait (line 191) | void wait() {
type QueuePair (line 213) | struct QueuePair : NoMove {
method QueuePair (line 215) | QueuePair(const ProtectionDomain& pd, const CompletionQueue& cq) {
method num (line 237) | uint32_t num() {
method init (line 241) | void init(const Port& port, int accessFlags) {
method rtr (line 257) | void rtr(const Port& port,
method rts (line 289) | void rts() {
method read (line 308) | void read(MemoryRegion& dstmr,
type rdma (line 348) | namespace rdma {
type ibBuffer (line 350) | struct ibBuffer : Buffer {
method key (line 354) | virtual uint32_t key() override {
method keyFor (line 357) | virtual uint32_t keyFor(Endpoint ep) override {
type ibCompletionQueue (line 362) | struct ibCompletionQueue : CompletionQueue {
method ibCompletionQueue (line 366) | ibCompletionQueue(ib::Context& ctx, int size)
method wait (line 369) | virtual void wait() override {
type ibMultiBuffer (line 374) | struct ibMultiBuffer : Buffer {
method key (line 379) | virtual uint32_t key() override {
method keyFor (line 390) | virtual uint32_t keyFor(Endpoint ep) override {
type ibHost (line 395) | struct ibHost : Host {
method ibHost (line 404) | ibHost(ib::Context* context, ib::ProtectionDomain* pd)
method Endpoint (line 413) | virtual Endpoint init(CompletionQueue& cqa) override {
method connect (line 421) | virtual void connect(Endpoint ep) override {
method read (line 425) | virtual void read(Buffer& localBuffer,
method wait (line 441) | virtual void wait() override {
type ibContext (line 446) | struct ibContext : Context {
method ibContext (line 450) | ibContext(ib::Device device)
method createHost (line 457) | virtual std::unique_ptr<Host> createHost() override {
method createBuffer (line 460) | virtual std::unique_ptr<Buffer> createBuffer(void* address,
method createCQ (line 467) | virtual std::unique_ptr<CompletionQueue> createCQ(int size) override {
type ibMultiCompletionQueue (line 472) | struct ibMultiCompletionQueue : CompletionQueue {
method wait (line 476) | virtual void wait() override {
type ibMultiHost (line 481) | struct ibMultiHost : ibHost {
method ibMultiHost (line 483) | ibMultiHost(size_t index, ib::Context* context, ib::ProtectionDomain...
method Endpoint (line 489) | virtual Endpoint init(CompletionQueue& cqa) override {
type ibMultiContext (line 495) | struct ibMultiContext : Context {
method ibMultiContext (line 499) | ibMultiContext() {
method createHost (line 510) | virtual std::unique_ptr<Host> createHost() override {
method createBuffer (line 516) | virtual std::unique_ptr<Buffer> createBuffer(void* address,
method createCQ (line 526) | virtual std::unique_ptr<CompletionQueue> createCQ(int size) override {
function create (line 535) | std::unique_ptr<Context> create() {
FILE: src/distributed/network.cc
type network (line 10) | namespace network {
type Handle (line 12) | struct Handle {
method Handle (line 14) | Handle() {
method Handle (line 16) | Handle(T& obj)
method Handle (line 20) | Handle(std::nullptr_t) {
method Handle (line 22) | Handle(Handle&& n) {
method Handle (line 25) | Handle(const Handle& n) {
method Handle (line 28) | Handle& operator=(Handle&& n) {
method Handle (line 32) | Handle& operator=(const Handle& n) {
method acquire (line 36) | void acquire(T* newobj) {
method release (line 42) | void release() {
method T (line 53) | T& operator*() const {
method T (line 56) | T* operator->() const {
type Ref (line 64) | struct Ref {
method ref (line 66) | Handle<T> ref() {
type Cache (line 71) | struct Cache {
type entry (line 72) | struct entry {
method entry (line 80) | static entry* get(T* ptr) {
method T (line 85) | T* allocate(A&&... args) {
method free (line 102) | void free(T* obj) {
method make (line 123) | Handle<T> make(A&&... args) {
type Wrapper (line 128) | struct Wrapper : Ref<Wrapper<T>> {
method Wrapper (line 132) | Wrapper(Cache<Wrapper<T>>* owner, A&&... args)
method T (line 136) | T* operator->() {
method T (line 139) | T& operator*() {
type Buffer (line 144) | struct Buffer : Ref<Buffer<maxsize>> {
method Buffer (line 149) | Buffer(Cache<Buffer>* owner)
method space (line 152) | size_t space() {
method append (line 155) | size_t append(const void* data, size_t n) {
method free (line 161) | void free(size_t n) {
method size (line 167) | size_t size() const {
method empty (line 170) | bool empty() const {
function decodeEndpoint (line 175) | std::pair<std::string_view, int> decodeEndpoint(std::string_view endpo...
class PeerImpl (line 203) | class PeerImpl : public Ref<PeerImpl> {
method PeerImpl (line 221) | PeerImpl(Cache<PeerImpl>* owner, asio::io_context& context)
method connect (line 226) | void connect(std::string_view endpoint) {
method asyncRead (line 280) | void asyncRead(size_t offset = 0) {
method setConnected (line 288) | void setConnected(asio::ip::tcp::socket sock) {
method connect (line 303) | void connect(asio::ip::tcp::endpoint ep) {
method failure (line 321) | void failure() {
method callSend (line 347) | void callSend(std::vector<char> buffer, size_t offset) {
method flush (line 369) | void flush() {
method sendNoFlush (line 380) | void sendNoFlush(const void* data, size_t n) {
method send (line 435) | void send(const void* data, size_t n) {
method sendMessage (line 443) | void sendMessage(const void* data, size_t n) {
type CallbackCounter (line 451) | struct CallbackCounter {
method CallbackCounter (line 453) | CallbackCounter(std::atomic_int& c)
method setOnReceive (line 467) | void setOnReceive(std::function<void(const void*, size_t)> callback,
method setOnMessage (line 481) | void setOnMessage(std::function<void(const void*, size_t)> callback,
method onReceive (line 497) | void onReceive(const asio::error_code& ec, size_t n) {
method lock (line 559) | std::unique_lock<std::mutex> lock() {
method close (line 563) | void close() {
method post_close (line 580) | void post_close() {
method setOnConnectionClosed (line 584) | void setOnConnectionClosed(std::function<void()> callback) {
class ServerImpl (line 589) | class ServerImpl : public Ref<ServerImpl> {
method ServerImpl (line 603) | ServerImpl(Cache<ServerImpl>* owner, asio::io_context& context)
method asyncAccept (line 611) | void asyncAccept(Handle<Wrapper<asio::ip::tcp::acceptor>> h,
method bind (line 626) | void bind(asio::ip::tcp::endpoint ep) {
method bind (line 660) | void bind(std::string_view endpoint) {
method listen (line 702) | void listen(std::string_view endpoint) {
method setOnPeer (line 710) | void setOnPeer(std::function<void(Handle<PeerImpl>)> callback) {
method lock (line 717) | std::unique_lock<std::mutex> lock() {
method close (line 721) | void close() {
class NetworkImpl (line 731) | class NetworkImpl {
method connect (line 743) | Handle<PeerImpl> connect(std::string_view endpoint) {
method listen (line 749) | Handle<ServerImpl> listen(std::string_view endpoint) {
method wrap (line 756) | static std::unique_ptr<T, std::function<void(T*)>> wrap(Handle<T> h) {
method run_one (line 762) | bool run_one() {
method post (line 766) | void post(std::function<void()> f) {
function Peer (line 879) | Peer Network::connect(std::string_view endpoint) {
function Server (line 883) | Server Network::listen(std::string_view endpoint) {
FILE: src/distributed/network.h
function namespace (line 8) | namespace network {
FILE: src/distributed/rdma.h
function namespace (line 9) | namespace rdma {
type Endpoint (line 15) | struct Endpoint {
type Buffer (line 27) | struct Buffer {
type CompletionQueue (line 34) | struct CompletionQueue {
type Host (line 40) | struct Host {
type Context (line 54) | struct Context {
FILE: src/distributed/rdma_nop.cc
type rdma (line 3) | namespace rdma {
function create (line 5) | std::unique_ptr<Context> create() {
FILE: src/distributed/rpc.h
function namespace (line 19) | namespace rpc {
function write (line 38) | void write(std::string_view str) {
function clear (line 48) | void clear() {
function readStringView (line 74) | struct Deserializer {
function read (line 115) | void read(std::string_view& r) {
function read (line 118) | void read(std::string& r) {
type Serialize (line 153) | struct Serialize {
FILE: src/games/amazons.cc
type Amazons (line 17) | namespace Amazons {
function Player (line 177) | constexpr Player State::chessToPlayer(Chess chess) {
function Chess (line 187) | constexpr Chess State::playerToQueenChess(Player player) {
function Chess (line 196) | constexpr Chess State::playerToArrowChess(Player player) {
function Player (line 279) | Player State::turnPlayer() {
FILE: src/games/amazons.h
function namespace (line 34) | namespace Amazons {
FILE: src/games/block_go.h
function class (line 13) | class StateForBlockGo : public core::State {
function class (line 39) | class Piece {
function class (line 60) | class Move {
function State (line 90) | StateForBlockGo(int seed)
function virtual (line 94) | virtual void Initialize() override {
function initHash (line 117) | void initHash() {
function gameInit (line 132) | void gameInit() {
function virtual (line 253) | virtual std::unique_ptr<core::State> clone_() const override {
function findFeature (line 278) | void findFeature() {
function canDrop (line 295) | bool canDrop(int x, int y) {
function legalMoves (line 300) | void legalMoves(std::vector<Piece> player, std::vector<Move>& moves) {
function findActions (line 404) | void findActions() {
FILE: src/games/breakthrough.cc
function BTinitHash (line 32) | void BTinitHash() {
FILE: src/games/breakthrough.h
function class (line 48) | class BTPlayer {
function class (line 62) | class BTMove {
function class (line 97) | class BTBoard {
FILE: src/games/breakthrough_state.h
function virtual (line 77) | virtual std::unique_ptr<core::State> clone_() const override {
function findActions (line 95) | void findActions(int color) {
function findFeatures (line 112) | void findFeatures() {
function virtual (line 129) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 183) | virtual void DoGoodAction() override {
FILE: src/games/chess.cc
type chess (line 10) | namespace chess {
type ZobrishHash (line 12) | struct ZobrishHash {
method ZobrishHash (line 14) | ZobrishHash() {
FILE: src/games/chess.h
function namespace (line 17) | namespace chess {
FILE: src/games/chinesecheckers.cc
type ChineseCheckers (line 14) | namespace ChineseCheckers {
function string (line 16) | string Board::sprintBoard(string_view prefix,
function string (line 23) | string Board::getPosStr(int p) const {
function string (line 53) | string Board::showBoard(bool prePlay) const {
function Player (line 302) | constexpr Player Game::chessToPlayer(Chess chess) {
function Chess (line 311) | constexpr Chess Game::playerToChess(Player player) {
function Player (line 402) | Player State::changeTurn(Player player) {
function string (line 491) | string State::stateDescription() const {
function string (line 496) | string State::actionDescription(const ::_Action& action) const {
function string (line 513) | string State::actionsDescription() const {
FILE: src/games/chinesecheckers.h
function namespace (line 27) | namespace ChineseCheckers {
FILE: src/games/commons/hash.h
function T (line 23) | constexpr T operator[](size_t i) const {
function reset (line 40) | void reset() {
function trigger (line 44) | void trigger(size_t i) {
FILE: src/games/commons/player.h
function class (line 14) | class Player {
FILE: src/games/connect6.h
function namespace (line 20) | namespace Connect6 {
FILE: src/games/connect6_state.h
function namespace (line 21) | namespace Connect6 {
function humanInputAction (line 255) | int humanInputAction(
FILE: src/games/connectfour.h
function class (line 17) | class StateForConnectFour : public core::State {
function virtual (line 132) | virtual void DoGoodAction() override {
FILE: src/games/diceshogi.h
function virtual (line 39) | virtual void Initialize() override {
function gameInit (line 64) | void gameInit() {
function initHash (line 102) | void initHash() {
function findFeature (line 124) | void findFeature() {
function findActions (line 310) | void findActions() {
function fourfold (line 534) | bool fourfold() {
function won (line 540) | bool won(int color) {
function virtual (line 556) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 636) | virtual void DoGoodAction() override {
FILE: src/games/diceshogi_state.h
type Coord (line 17) | typedef unsigned short Coord;
function class (line 31) | class ActionForDiceshogi : public _Action {
function class (line 45) | class StateForDiceshogi : public core::State {
function init (line 66) | void init() {
function virtual (line 108) | virtual std::unique_ptr<core::State> clone_() const override {
function won (line 118) | bool won(int color) {
function virtual (line 144) | virtual std::string actionsDescription() override {
function virtual (line 164) | virtual std::string actionDescription(const _Action& action) const {
function print_chess (line 179) | void print_chess(int color, FILE* fp) {
function legal_king_moves (line 195) | void legal_king_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_gold_moves (line 207) | void legal_gold_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_silver_moves (line 230) | void legal_silver_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_bishop_moves (line 269) | void legal_bishop_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_rook_moves (line 308) | void legal_rook_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_pawn_moves (line 347) | void legal_pawn_moves(DSMove origin, std::vector<DSMove>& moves) {
function legal_drop (line 381) | void legal_drop(DSMove origin, std::vector<DSMove>& moves) {
function legal_drop_pawn (line 393) | void legal_drop_pawn(DSMove origin, std::vector<DSMove>& moves) {
function can_eat (line 440) | bool can_eat(DSPosition tar, int color) {
function checkmate (line 452) | bool checkmate(DSPiece king) {
function legalDSMoves (line 468) | void legalDSMoves(int color, std::vector<DSMove>& moves) {
function legalDSMoves_onboard (line 501) | void legalDSMoves_onboard(int color, std::vector<DSMove>& moves) {
function opponent (line 545) | int opponent(int player) {
function DSPieceType (line 551) | DSPieceType new_type(DSPieceType p) {
function play (line 590) | void play(DSMove m) {
function getHashNum (line 668) | int getHashNum(DSPiece p) {
function getHashNumE (line 680) | int getHashNumE(DSPiece p) {
function virtual (line 687) | virtual void Initialize() override {
function type_to_z (line 730) | int type_to_z(DSPiece p) {
function DSPieceType (line 760) | DSPieceType z_to_type(int z) const {
function z_promoted (line 802) | bool z_promoted(int z) const {
function findActions (line 806) | void findActions(int color) {
function findFeatures (line 835) | void findFeatures() {
function virtual (line 1022) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 1090) | virtual void DoGoodAction() override {
FILE: src/games/einstein.h
function class (line 12) | class StateForEinstein : public core::State {
function class (line 46) | class Move {
function State (line 73) | StateForEinstein(int seed)
function virtual (line 79) | virtual void Initialize() override {
function initHash (line 102) | void initHash() {
function gameInit (line 118) | void gameInit() {
function virtual (line 136) | virtual void setStateFromStr(const std::string& str) override {
function virtual (line 178) | virtual std::unique_ptr<core::State> clone_() const override {
function virtual (line 221) | virtual std::string actionDescription(const _Action& action) const overr...
function findFeature (line 233) | void findFeature() {
function legalMoves (line 274) | void legalMoves(int color, std::vector<Move>& moves) {
function findActions (line 357) | void findActions() {
function virtual (line 438) | virtual void DoGoodAction() override {
FILE: src/games/game_action.h
function class (line 11) | class GameAction {}
FILE: src/games/game_base.h
type StateType (line 20) | typedef StateType State;
type std (line 21) | typedef std::vector<Action> History;
function Reset (line 37) | void Reset() {
function SetTurnPlayer (line 50) | void SetTurnPlayer(PLAYER turn_player) {
function GetHistory (line 53) | void GetHistory(History& history) const {
function Action (line 56) | Action GetLastAction() {
function PLAYER (line 62) | PLAYER GetWinPlayer() {
FILE: src/games/game_player.h
type PLAYER (line 11) | enum PLAYER {
function PLAYER (line 22) | inline PLAYER IntToPlayer(int i) {
FILE: src/games/game_state.h
function class (line 11) | class GameState {}
FILE: src/games/gomoku_swap2.cc
type GomokuSwap2 (line 10) | namespace GomokuSwap2 {
function Player (line 95) | Player Game::chessToPlayer(Chess chess) {
function Chess (line 105) | Chess Game::playerToChess(Player player) {
FILE: src/games/gomoku_swap2.h
function namespace (line 20) | namespace GomokuSwap2 {
FILE: src/games/havannah.h
function namespace (line 19) | namespace Havannah {
FILE: src/games/havannah_state.h
function namespace (line 16) | namespace Havannah {
FILE: src/games/hex.h
function namespace (line 18) | namespace Hex {
FILE: src/games/hex_state.h
function namespace (line 16) | namespace Hex {
function State (line 45) | State(seed) {
FILE: src/games/kyotoshogi.h
type KSPieceType (line 22) | enum KSPieceType {
type KSPieceZ (line 35) | enum KSPieceZ {
function class (line 257) | class KSPosition {
function on_board (line 269) | bool on_board() {
function class (line 283) | class KSPiece {
function operator (line 303) | bool operator==(const KSPiece& p) {
function addKSPiece (line 308) | void addKSPiece(int c, KSPieceType t, bool p, KSPosition position) {
function class (line 401) | class KSMove {
FILE: src/games/kyotoshogi_state.h
type Coord (line 10) | typedef unsigned short Coord;
function class (line 25) | class StateForKyotoshogi : public core::State {
FILE: src/games/ludii/jni_utils.cc
type Ludii (line 30) | namespace Ludii {
function JNIEnv (line 37) | JNIEnv* JNIUtils::GetEnv() {
function jclass (line 142) | jclass JNIUtils::LudiiGameWrapperClass() {
function jclass (line 146) | jclass JNIUtils::LudiiStateWrapperClass() {
FILE: src/games/ludii/jni_utils.h
function namespace (line 33) | namespace Ludii {
FILE: src/games/ludii/ludii_game_wrapper.cc
type Ludii (line 17) | namespace Ludii {
function LudiiGameWrapper (line 147) | LudiiGameWrapper& LudiiGameWrapper::operator=(LudiiGameWrapper const& ...
FILE: src/games/ludii/ludii_game_wrapper.h
function namespace (line 22) | namespace Ludii {
FILE: src/games/ludii/ludii_state_wrapper.cc
type Ludii (line 17) | namespace Ludii {
function LudiiStateWrapper (line 215) | LudiiStateWrapper& LudiiStateWrapper::operator=(
FILE: src/games/ludii/ludii_state_wrapper.h
function namespace (line 26) | namespace Ludii {
FILE: src/games/mastermind_state.h
function namespace (line 32) | namespace Mastermind {
FILE: src/games/minesweeper.cc
type Minesweeper (line 13) | namespace Minesweeper {
function sparseMaskToString (line 29) | std::string sparseMaskToString(const SparseMask& mask) {
FILE: src/games/minesweeper_common.h
function namespace (line 24) | namespace Minesweeper {
function class (line 44) | class BoardPosition {
function isInBoard (line 72) | constexpr bool isInBoard(int row, int col) {
type GameDefs (line 93) | struct GameDefs {
function std (line 112) | static std::string boardToString(const Board& board) {
function std (line 146) | static std::string minesToString(const Mines& mines) {
function zero (line 215) | void zero() {
function set (line 221) | void set(int row, int col) {
function typename (line 228) | typename BoardMask::value_type get(int row, int col) const {
FILE: src/games/minesweeper_csp_vkms/ConnectedComponent.h
function namespace (line 12) | namespace csp {
FILE: src/games/minesweeper_csp_vkms/CspStrategy.h
function namespace (line 14) | namespace csp {
function getUnconstrainedVarProba (line 171) | float getUnconstrainedVarProba(size_t count) const {
function initializeActiveConstraints (line 372) | void initializeActiveConstraints(const Board& board) {
function initializeUnconstrainedVariables (line 402) | void initializeUnconstrainedVariables(const Board& board) {
FILE: src/games/minesweeper_csp_vkms/SolutionSet.h
function namespace (line 12) | namespace csp {
function assignNotMine (line 177) | void assignNotMine(size_t i) {
function enumerateSolutions (line 379) | void enumerateSolutions(const Board& board, const _Mask& mines) {
function enumerateSolutionsDebug (line 413) | void enumerateSolutionsDebug(const Board& board) {
FILE: src/games/minesweeper_csp_vkms/SolutionSetSampler.h
function namespace (line 12) | namespace csp {
function canSampleNumMinesFromSet (line 319) | bool canSampleNumMinesFromSet(size_t numMines, size_t setIdx) {
function nextMinesCount (line 328) | size_t nextMinesCount(size_t countHint, size_t setIdx) {
function computeSolutionSetsOrder (line 346) | void computeSolutionSetsOrder() {
function initializeMinMaxMinesStats (line 371) | void initializeMinMaxMinesStats() {
function adjustMinMaxMinesStats (line 390) | void adjustMinMaxMinesStats() {
FILE: src/games/minesweeper_csp_vkms/csp_vkms.cc
function good_action_eval (line 18) | float good_action_eval(core::State& s) {
function get_map_str (line 36) | std::string get_map_str() {
function benchmark_vkms (line 43) | void benchmark_vkms() {
function main (line 56) | int main(int, char**) {
FILE: src/games/minesweeper_state.h
function namespace (line 26) | namespace Minesweeper {
function virtual (line 136) | virtual int parseAction(const std::string& str) const override {
function expandZeros (line 240) | void expandZeros(Board& board, const Board& boardSample, int row, int co...
function hasDuplicates (line 317) | static bool hasDuplicates(const Mines& mines) {
function checkMinesSample (line 329) | static void checkMinesSample(Mines& minesSample) {
function checkConsistency (line 344) | static void checkConsistency(const Board& boardSample, const Board& boar...
function minesToBoard (line 352) | void minesToBoard(const Mines& mines, Board& board) {
function fillLegalActions (line 373) | static void fillLegalActions(std::vector<::_Action>& legalActions,
function fillFeatures (line 402) | static void fillFeatures(std::vector<float>& features, const Board& boar...
function displayBoard (line 409) | static void displayBoard(const std::string& title, const Board& board) {
function displayMines (line 415) | static void displayMines(const std::string& title, const Mines& mines) {
function boardAllUnknown (line 421) | static bool boardAllUnknown(const Board& board) {
function done (line 430) | bool done() const {
function boardHash (line 440) | uint64_t boardHash() {
FILE: src/games/minishogi.h
type Repetition (line 35) | struct Repetition {
function virtual (line 49) | virtual void Initialize() override {
function gameInit (line 80) | void gameInit() {
function virtual (line 651) | virtual void DoGoodAction() override {
FILE: src/games/mnkgame.h
function namespace (line 31) | namespace MNKGame {
function Move (line 118) | Move move{}
FILE: src/games/nogo_action.cc
function Position (line 23) | Position NoGoAction::GetPosition() const {
FILE: src/games/nogo_action.h
function class (line 17) | class NoGoAction : public GameAction {
FILE: src/games/nogo_bitboard.h
function class (line 12) | class NoGoBitBoard {
FILE: src/games/nogo_game.cc
function NoGoGame (line 31) | NoGoGame& NoGoGame::operator=(const NoGoGame& rhs) {
function NoGoState (line 40) | NoGoState NoGoGame::GetNoGoState() {
function NoGoBitBoard (line 76) | NoGoBitBoard NoGoGame::GetIllegalBitBoard() {
function PLAYER (line 98) | PLAYER NoGoGame::GetPositionPlayer(Position position) {
FILE: src/games/nogo_position.h
type Position (line 17) | typedef int Position;
type SYMMETRYTYPE (line 20) | enum SYMMETRYTYPE {
function namespace (line 32) | namespace symmetry {
function operator (line 92) | inline bool operator==(const Point& rhs) const {
function operator (line 95) | inline bool operator!=(const Point& rhs) const {
function Position (line 107) | inline Position GetPosition() {
function ToSymmetryOf (line 110) | inline void ToSymmetryOf(SYMMETRYTYPE type) {
function MinusY (line 162) | inline void MinusY() {
function ChangeXY (line 165) | inline void ChangeXY() {
function Shift (line 170) | inline void Shift() {
function ShiftBack (line 175) | inline void ShiftBack() {
FILE: src/games/nogo_state.cc
function NoGoState (line 85) | NoGoState& NoGoState::operator=(const NoGoState& rhs) {
function PLAYER (line 116) | PLAYER NoGoState::GetPlayer(Position position) const {
function Position (line 247) | Position NoGoState::FindParent(Position position) {
FILE: src/games/nogo_zestate.h
type Coord (line 11) | typedef unsigned short Coord;
function class (line 24) | class StateForNogo : public State {
function virtual (line 77) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 149) | virtual void DoGoodAction() override {
FILE: src/games/othello.h
function namespace (line 34) | namespace Othello {
function State (line 109) | State(seed) {
function Move (line 137) | Move move{}
FILE: src/games/othello_opt.cc
type Othello2 (line 16) | namespace Othello2 {
function isInBoard (line 25) | static constexpr bool isInBoard(int row, int col) {
function arrGet (line 31) | static typename Array::reference arrGet(Array& arr, size_t row, size_t...
function arrGet (line 36) | static typename Array::const_reference arrGet(const Array& arr,
class State<4> (line 387) | class State<4>
class State<6> (line 388) | class State<6>
class State<8> (line 389) | class State<8>
class State<10> (line 390) | class State<10>
class State<12> (line 391) | class State<12>
class State<14> (line 392) | class State<14>
class State<16> (line 393) | class State<16>
FILE: src/games/othello_opt.h
function namespace (line 15) | namespace Othello2 {
FILE: src/games/outeropengomoku_new.h
function class (line 17) | class StateForOOGomoku : public core::State {
function virtual (line 143) | virtual void DoGoodAction() override {
FILE: src/games/shogi.h
function class (line 13) | class Shogi {
function class (line 157) | class Move {
function king_moves (line 168) | void king_moves(Piece p, std::vector<Move>& moves) {
function gold_moves (line 182) | void gold_moves(Piece p, std::vector<Move>& moves) {
function silver_moves (line 207) | void silver_moves(Piece p, std::vector<Move>& moves) {
function bishop_moves (line 248) | void bishop_moves(Piece p, std::vector<Move>& moves) {
function rook_moves (line 289) | void rook_moves(Piece p, std::vector<Move>& moves) {
function pawn_moves (line 330) | void pawn_moves(Piece p, std::vector<Move>& moves) {
function legal_rook_moves (line 709) | void legal_rook_moves(Piece p, std::vector<Move>& moves) {
FILE: src/games/surakarta.h
function class (line 36) | class SKHash {
function class (line 59) | class SKPlayer {
function class (line 68) | class SKMove {
function class (line 81) | class SKBoard {
FILE: src/games/surakarta_state.h
type Coord (line 17) | typedef unsigned short Coord;
function virtual (line 37) | virtual void Initialize() override {
function virtual (line 101) | virtual std::string actionDescription(const _Action& action) const {
function virtual (line 114) | virtual int parseAction(const std::string& str) const override {
function virtual (line 138) | virtual std::unique_ptr<core::State> clone_() const override {
function findFeatures (line 156) | void findFeatures() {
function virtual (line 182) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 229) | virtual void DoGoodAction() override {
FILE: src/games/tristan_nogo.cc
function initHash (line 39) | void initHash() {
function ajoute (line 54) | bool ajoute(int* stack, int elt) {
FILE: src/games/tristan_nogo.h
function class (line 67) | class NogoMove {
function class (line 99) | class NogoBoard {
FILE: src/games/tristannogo_state.h
function virtual (line 73) | virtual std::unique_ptr<core::State> clone_() const override {
function findFeatures (line 89) | void findFeatures() {
function virtual (line 129) | virtual void ApplyAction(const _Action& action) override {
function virtual (line 161) | virtual void DoGoodAction() override {
FILE: src/games/weakschur/SchurMatrix.hpp
class SchurMatrix (line 14) | class SchurMatrix {
FILE: src/games/weakschur/SchurVector.hpp
class SchurVector (line 13) | class SchurVector {
FILE: src/games/weakschur/WeakSchur.hpp
class WeakSchur (line 15) | class WeakSchur {
FILE: src/games/weakschur/weakschur_state.h
function namespace (line 15) | namespace weakschur {
FILE: src/games/yinsh.cc
function string (line 28) | string StateForYinsh::stateDescription(void) const {
function string (line 31) | string StateForYinsh::actionsDescription(void) const {
FILE: src/games/yinsh.h
function piece (line 29) | enum class piece : int {
FILE: src/mcts/actor.h
function namespace (line 15) | namespace mcts {
FILE: src/mcts/mcts.cc
type mcts (line 16) | namespace mcts {
function forcedRollouts (line 18) | int forcedRollouts(float piValue, int numVisits, const MctsOption& opt...
function puctValue (line 23) | float puctValue(int rootPlayerId,
function Action (line 43) | Action pickBestAction(int rootPlayerId,
function computeRolloutsImpl (line 144) | int computeRolloutsImpl(const std::vector<Node*>& rootNode,
function computeRollouts (line 475) | int computeRollouts(const std::vector<Node*>& rootNode,
FILE: src/mcts/mcts.h
function namespace (line 26) | namespace mcts {
FILE: src/mcts/node.cc
type mcts (line 13) | namespace mcts {
function Node (line 39) | Node* Node::newChild(Node* child, Action action) {
function Node (line 51) | Node* Node::getChild(Action action) const {
FILE: src/mcts/node.h
function namespace (line 18) | namespace mcts {
FILE: src/mcts/player.h
function namespace (line 12) | namespace mcts {
FILE: src/mcts/pybind.cc
function PYBIND11_MODULE (line 14) | PYBIND11_MODULE(mcts, m) {
FILE: src/mcts/storage.cc
type mcts (line 4) | namespace mcts {
function Node (line 9) | Node* Storage::newNode() {
function Storage (line 38) | Storage* Storage::getStorage() {
FILE: src/mcts/storage.h
function namespace (line 15) | namespace mcts {
FILE: src/mcts/test.cc
class TicTacToeState (line 22) | class TicTacToeState : public State {
method TicTacToeState (line 24) | TicTacToeState()
method getCurrentPlayer (line 32) | int getCurrentPlayer() const override {
method getHash (line 36) | uint64_t getHash() const override {
method getReward (line 40) | float getReward(int player) const override {
method getLegalActions (line 51) | std::vector<int> getLegalActions() const {
method getRandomRolloutReward (line 61) | float getRandomRolloutReward(int player) const override {
method getStepIdx (line 93) | int getStepIdx() const override {
method clone (line 97) | std::unique_ptr<State> clone() const override {
method forward (line 110) | bool forward(const Action& a) override {
method terminated (line 121) | bool terminated() const override {
method at (line 125) | int at(int i, int j) const {
method checkSum (line 131) | void checkSum(int sum, int* winner) const {
method checkWinner (line 138) | int checkWinner() const {
method printState (line 166) | void printState() {
class TestActor (line 186) | class TestActor : public Actor {
method TestActor (line 188) | TestActor() {
method PiVal (line 191) | PiVal& evaluate(const State& s, PiVal& pival) override {
function main (line 207) | int main(int argc, char* argv[]) {
FILE: src/mcts/types.h
function namespace (line 12) | namespace mcts {
FILE: src/mcts/utils.h
function namespace (line 24) | namespace mcts {
function printPolicy (line 263) | inline void printPolicy(const std::vector<float>& pi) {
FILE: src/third_party/asio/associated_allocator.hpp
type asio (line 24) | namespace asio {
type detail (line 25) | namespace detail {
type associated_allocator_check (line 28) | struct associated_allocator_check
type associated_allocator_impl (line 34) | struct associated_allocator_impl
method type (line 38) | static type get(const T&, const E& e) ASIO_NOEXCEPT
type associated_allocator_impl<T, E,
typename associated_allocator_check<typename T::allocator_type>::type> (line 45) | struct associated_allocator_impl<T, E,
method type (line 50) | static type get(const T& t, const E&) ASIO_NOEXCEPT
type associated_allocator (line 78) | struct associated_allocator
method type (line 90) | static type get(const T& t,
function get_associated_allocator (line 102) | inline typename associated_allocator<T>::type
function get_associated_allocator (line 113) | inline typename associated_allocator<T, Allocator>::type
FILE: src/third_party/asio/associated_executor.hpp
type asio (line 25) | namespace asio {
type detail (line 26) | namespace detail {
type associated_executor_check (line 29) | struct associated_executor_check
type associated_executor_impl (line 35) | struct associated_executor_impl
method type (line 39) | static type get(const T&, const E& e) ASIO_NOEXCEPT
type associated_executor_impl<T, E,
typename associated_executor_check<typename T::executor_type>::type> (line 46) | struct associated_executor_impl<T, E,
method type (line 51) | static type get(const T& t, const E&) ASIO_NOEXCEPT
type associated_executor (line 79) | struct associated_executor
method type (line 91) | static type get(const T& t,
function get_associated_executor (line 103) | inline typename associated_executor<T>::type
function get_associated_executor (line 114) | inline typename associated_executor<T, Executor>::type
function get_associated_executor (line 128) | inline typename associated_executor<T,
FILE: src/third_party/asio/async_result.hpp
type asio (line 24) | namespace asio {
type detail (line 30) | namespace detail {
type is_completion_signature (line 33) | struct is_completion_signature : false_type
type is_completion_handler_for (line 49) | struct is_completion_handler_for : false_type
type async_result_helper (line 255) | struct async_result_helper
type async_result_memfns_base (line 260) | struct async_result_memfns_base
type async_result_memfns_derived (line 266) | struct async_result_memfns_derived
type async_result_memfns_check (line 272) | struct async_result_memfns_check
type async_result_has_initiate_memfn (line 286) | struct async_result_has_initiate_memfn
type initiation_archetype (line 480) | struct initiation_archetype
type default_completion_token_check (line 512) | struct default_completion_token_check
type default_completion_token_impl (line 518) | struct default_completion_token_impl
type default_completion_token_impl<T,
typename default_completion_token_check<
typename T::default_completion_token_type>::type> (line 524) | struct default_completion_token_impl<T,
class async_result (line 105) | class async_result
method async_result (line 120) | explicit async_result(completion_handler_type& h)
method return_type (line 126) | return_type get()
class async_result<void, Signature> (line 194) | class async_result<void, Signature>
type async_completion (line 205) | struct async_completion
method async_completion (line 218) | explicit async_completion(CompletionToken& token)
method async_completion (line 226) | explicit async_completion(typename decay<CompletionToken>::type& token)
method async_completion (line 232) | explicit async_completion(const typename decay<CompletionToken>::typ...
type detail (line 252) | namespace detail {
type is_completion_signature (line 33) | struct is_completion_signature : false_type
type is_completion_handler_for (line 49) | struct is_completion_handler_for : false_type
type async_result_helper (line 255) | struct async_result_helper
type async_result_memfns_base (line 260) | struct async_result_memfns_base
type async_result_memfns_derived (line 266) | struct async_result_memfns_derived
type async_result_memfns_check (line 272) | struct async_result_memfns_check
type async_result_has_initiate_memfn (line 286) | struct async_result_has_initiate_memfn
type initiation_archetype (line 480) | struct initiation_archetype
type default_completion_token_check (line 512) | struct default_completion_token_check
type default_completion_token_impl (line 518) | struct default_completion_token_impl
type default_completion_token_impl<T,
typename default_completion_token_check<
typename T::default_completion_token_type>::type> (line 524) | struct default_completion_token_impl<T,
type detail (line 477) | namespace detail {
type is_completion_signature (line 33) | struct is_completion_signature : false_type
type is_completion_handler_for (line 49) | struct is_completion_handler_for : false_type
type async_result_helper (line 255) | struct async_result_helper
type async_result_memfns_base (line 260) | struct async_result_memfns_base
type async_result_memfns_derived (line 266) | struct async_result_memfns_derived
type async_result_memfns_check (line 272) | struct async_result_memfns_check
type async_result_has_initiate_memfn (line 286) | struct async_result_has_initiate_memfn
type initiation_archetype (line 480) | struct initiation_archetype
type default_completion_token_check (line 512) | struct default_completion_token_check
type default_completion_token_impl (line 518) | struct default_completion_token_impl
type default_completion_token_impl<T,
typename default_completion_token_check<
typename T::default_completion_token_type>::type> (line 524) | struct default_completion_token_impl<T,
type detail (line 509) | namespace detail {
type is_completion_signature (line 33) | struct is_completion_signature : false_type
type is_completion_handler_for (line 49) | struct is_completion_handler_for : false_type
type async_result_helper (line 255) | struct async_result_helper
type async_result_memfns_base (line 260) | struct async_result_memfns_base
type async_result_memfns_derived (line 266) | struct async_result_memfns_derived
type async_result_memfns_check (line 272) | struct async_result_memfns_check
type async_result_has_initiate_memfn (line 286) | struct async_result_has_initiate_memfn
type initiation_archetype (line 480) | struct initiation_archetype
type default_completion_token_check (line 512) | struct default_completion_token_check
type default_completion_token_impl (line 518) | struct default_completion_token_impl
type default_completion_token_impl<T,
typename default_completion_token_check<
typename T::default_completion_token_type>::type> (line 524) | struct default_completion_token_impl<T,
type default_completion_token (line 545) | struct default_completion_token
type default_completion_token (line 554) | struct default_completion_token
type is_completion_signature<R(Args...)> (line 38) | struct is_completion_signature<R(Args...)> : true_type
type is_completion_handler_for<T, R(Args...)> (line 54) | struct is_completion_handler_for<T, R(Args...)>
FILE: src/third_party/asio/awaitable.hpp
type asio (line 27) | namespace asio {
type detail (line 28) | namespace detail {
class awaitable_thread (line 33) | class awaitable_thread
class awaitable_frame (line 34) | class awaitable_frame
class awaitable (line 40) | class awaitable
method awaitable (line 50) | constexpr awaitable() noexcept
method awaitable (line 56) | awaitable(awaitable&& other) noexcept
method valid (line 69) | bool valid() const noexcept
method await_ready (line 77) | bool await_ready() const noexcept
method await_suspend (line 84) | void await_suspend(
method T (line 91) | T await_resume()
method awaitable (line 103) | awaitable(const awaitable&) = delete;
method awaitable (line 104) | awaitable& operator=(const awaitable&) = delete;
method awaitable (line 107) | explicit awaitable(detail::awaitable_frame<T, Executor>* a)
FILE: src/third_party/asio/basic_datagram_socket.hpp
type asio (line 29) | namespace asio {
class basic_datagram_socket (line 36) | class basic_datagram_socket
type rebind_executor (line 59) | struct rebind_executor
method basic_datagram_socket (line 87) | explicit basic_datagram_socket(const executor_type& ex)
method basic_datagram_socket (line 102) | explicit basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 121) | basic_datagram_socket(const executor_type& ex, const protocol_type& ...
method basic_datagram_socket (line 139) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 163) | basic_datagram_socket(const executor_type& ex, const endpoint_type& ...
method basic_datagram_socket (line 185) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 208) | basic_datagram_socket(const executor_type& ex,
method basic_datagram_socket (line 230) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 251) | basic_datagram_socket(basic_datagram_socket&& other) ASIO_NOEXCEPT
method basic_datagram_socket (line 268) | basic_datagram_socket& operator=(basic_datagram_socket&& other)
method basic_datagram_socket (line 287) | basic_datagram_socket(basic_datagram_socket<Protocol1, Executor1>&& ...
method send (line 353) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 380) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 408) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 452) | WriteHandler
method WriteHandler (line 496) | WriteHandler
method send_to (line 536) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 563) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 590) | std::size_t send_to(const ConstBufferSequence& buffers,
method WriteHandler (line 637) | WriteHandler
method WriteHandler (line 681) | WriteHandler
method receive (line 720) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 748) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 777) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 822) | ReadHandler
method ReadHandler (line 866) | ReadHandler
method receive_from (line 907) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 934) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 961) | std::size_t receive_from(const MutableBufferSequence& buffers,
method ReadHandler (line 1007) | ReadHandler
method ReadHandler (line 1053) | ReadHandler
class initiate_async_send (line 1069) | class initiate_async_send
method initiate_async_send (line 1074) | explicit initiate_async_send(basic_datagram_socket* self)
method executor_type (line 1079) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_send_to (line 1103) | class initiate_async_send_to
method initiate_async_send_to (line 1108) | explicit initiate_async_send_to(basic_datagram_socket* self)
method executor_type (line 1113) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1137) | class initiate_async_receive
method initiate_async_receive (line 1142) | explicit initiate_async_receive(basic_datagram_socket* self)
method executor_type (line 1147) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_from (line 1171) | class initiate_async_receive_from
method initiate_async_receive_from (line 1176) | explicit initiate_async_receive_from(basic_datagram_socket* self)
method executor_type (line 1181) | executor_type get_executor() const ASIO_NOEXCEPT
class basic_datagram_socket (line 50) | class basic_datagram_socket
type rebind_executor (line 59) | struct rebind_executor
method basic_datagram_socket (line 87) | explicit basic_datagram_socket(const executor_type& ex)
method basic_datagram_socket (line 102) | explicit basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 121) | basic_datagram_socket(const executor_type& ex, const protocol_type& ...
method basic_datagram_socket (line 139) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 163) | basic_datagram_socket(const executor_type& ex, const endpoint_type& ...
method basic_datagram_socket (line 185) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 208) | basic_datagram_socket(const executor_type& ex,
method basic_datagram_socket (line 230) | basic_datagram_socket(ExecutionContext& context,
method basic_datagram_socket (line 251) | basic_datagram_socket(basic_datagram_socket&& other) ASIO_NOEXCEPT
method basic_datagram_socket (line 268) | basic_datagram_socket& operator=(basic_datagram_socket&& other)
method basic_datagram_socket (line 287) | basic_datagram_socket(basic_datagram_socket<Protocol1, Executor1>&& ...
method send (line 353) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 380) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 408) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 452) | WriteHandler
method WriteHandler (line 496) | WriteHandler
method send_to (line 536) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 563) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 590) | std::size_t send_to(const ConstBufferSequence& buffers,
method WriteHandler (line 637) | WriteHandler
method WriteHandler (line 681) | WriteHandler
method receive (line 720) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 748) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 777) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 822) | ReadHandler
method ReadHandler (line 866) | ReadHandler
method receive_from (line 907) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 934) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 961) | std::size_t receive_from(const MutableBufferSequence& buffers,
method ReadHandler (line 1007) | ReadHandler
method ReadHandler (line 1053) | ReadHandler
class initiate_async_send (line 1069) | class initiate_async_send
method initiate_async_send (line 1074) | explicit initiate_async_send(basic_datagram_socket* self)
method executor_type (line 1079) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_send_to (line 1103) | class initiate_async_send_to
method initiate_async_send_to (line 1108) | explicit initiate_async_send_to(basic_datagram_socket* self)
method executor_type (line 1113) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1137) | class initiate_async_receive
method initiate_async_receive (line 1142) | explicit initiate_async_receive(basic_datagram_socket* self)
method executor_type (line 1147) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_from (line 1171) | class initiate_async_receive_from
method initiate_async_receive_from (line 1176) | explicit initiate_async_receive_from(basic_datagram_socket* self)
method executor_type (line 1181) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_deadline_timer.hpp
type asio (line 36) | namespace asio {
class basic_deadline_timer (line 129) | class basic_deadline_timer
type rebind_executor (line 137) | struct rebind_executor
method basic_deadline_timer (line 161) | explicit basic_deadline_timer(const executor_type& ex)
method basic_deadline_timer (line 177) | explicit basic_deadline_timer(ExecutionContext& context,
method basic_deadline_timer (line 195) | basic_deadline_timer(const executor_type& ex, const time_type& expir...
method basic_deadline_timer (line 215) | basic_deadline_timer(ExecutionContext& context, const time_type& exp...
method basic_deadline_timer (line 236) | basic_deadline_timer(const executor_type& ex,
method basic_deadline_timer (line 258) | basic_deadline_timer(ExecutionContext& context,
method basic_deadline_timer (line 283) | basic_deadline_timer(basic_deadline_timer&& other)
method basic_deadline_timer (line 300) | basic_deadline_timer& operator=(basic_deadline_timer&& other)
method executor_type (line 317) | executor_type get_executor() ASIO_NOEXCEPT
method cancel (line 344) | std::size_t cancel()
method cancel (line 374) | std::size_t cancel(asio::error_code& ec)
method cancel_one (line 403) | std::size_t cancel_one()
method cancel_one (line 436) | std::size_t cancel_one(asio::error_code& ec)
method time_type (line 446) | time_type expires_at() const
method expires_at (line 473) | std::size_t expires_at(const time_type& expiry_time)
method expires_at (line 504) | std::size_t expires_at(const time_type& expiry_time,
method duration_type (line 516) | duration_type expires_from_now() const
method expires_from_now (line 543) | std::size_t expires_from_now(const duration_type& expiry_time)
method expires_from_now (line 574) | std::size_t expires_from_now(const duration_type& expiry_time,
method wait (line 588) | void wait()
method wait (line 602) | void wait(asio::error_code& ec)
method WaitHandler (line 633) | WaitHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
class initiate_async_wait (line 650) | class initiate_async_wait
method initiate_async_wait (line 655) | explicit initiate_async_wait(basic_deadline_timer* self)
method executor_type (line 660) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_io_object.hpp
type asio (line 23) | namespace asio {
type detail (line 26) | namespace detail
class service_has_move (line 30) | class service_has_move
class basic_io_object (line 61) | class basic_io_object
method executor_type (line 104) | executor_type get_executor() ASIO_NOEXCEPT
method basic_io_object (line 115) | explicit basic_io_object(asio::io_context& io_context)
method service_type (line 159) | service_type& get_service()
method service_type (line 165) | const service_type& get_service() const
method implementation_type (line 171) | implementation_type& get_implementation()
method implementation_type (line 177) | const implementation_type& get_implementation() const
class basic_io_object<IoObjectService, true> (line 196) | class basic_io_object<IoObjectService, true>
method executor_type (line 216) | executor_type get_executor() ASIO_NOEXCEPT
method basic_io_object (line 222) | explicit basic_io_object(asio::io_context& io_context)
method basic_io_object (line 228) | basic_io_object(basic_io_object&& other)
method basic_io_object (line 235) | basic_io_object(IoObjectService1& other_service,
method basic_io_object (line 249) | basic_io_object& operator=(basic_io_object&& other)
method service_type (line 257) | service_type& get_service()
method service_type (line 262) | const service_type& get_service() const
method implementation_type (line 267) | implementation_type& get_implementation()
method implementation_type (line 272) | const implementation_type& get_implementation() const
FILE: src/third_party/asio/basic_raw_socket.hpp
type asio (line 29) | namespace asio {
class basic_raw_socket (line 36) | class basic_raw_socket
type rebind_executor (line 59) | struct rebind_executor
method basic_raw_socket (line 87) | explicit basic_raw_socket(const executor_type& ex)
method basic_raw_socket (line 102) | explicit basic_raw_socket(ExecutionContext& context,
method basic_raw_socket (line 121) | basic_raw_socket(const executor_type& ex, const protocol_type& proto...
method basic_raw_socket (line 139) | basic_raw_socket(ExecutionContext& context, const protocol_type& pro...
method basic_raw_socket (line 162) | basic_raw_socket(const executor_type& ex, const endpoint_type& endpo...
method basic_raw_socket (line 184) | basic_raw_socket(ExecutionContext& context, const endpoint_type& end...
method basic_raw_socket (line 206) | basic_raw_socket(const executor_type& ex,
method basic_raw_socket (line 228) | basic_raw_socket(ExecutionContext& context,
method basic_raw_socket (line 249) | basic_raw_socket(basic_raw_socket&& other) ASIO_NOEXCEPT
method basic_raw_socket (line 265) | basic_raw_socket& operator=(basic_raw_socket&& other)
method basic_raw_socket (line 284) | basic_raw_socket(basic_raw_socket<Protocol1, Executor1>&& other,
method send (line 347) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 373) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 400) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 444) | WriteHandler
method WriteHandler (line 488) | WriteHandler
method send_to (line 528) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 555) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 582) | std::size_t send_to(const ConstBufferSequence& buffers,
method WriteHandler (line 629) | WriteHandler
method WriteHandler (line 673) | WriteHandler
method receive (line 712) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 740) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 769) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 814) | ReadHandler
method ReadHandler (line 858) | ReadHandler
method receive_from (line 899) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 926) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 953) | std::size_t receive_from(const MutableBufferSequence& buffers,
method ReadHandler (line 999) | ReadHandler
method ReadHandler (line 1045) | ReadHandler
class initiate_async_send (line 1061) | class initiate_async_send
method initiate_async_send (line 1066) | explicit initiate_async_send(basic_raw_socket* self)
method executor_type (line 1071) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_send_to (line 1095) | class initiate_async_send_to
method initiate_async_send_to (line 1100) | explicit initiate_async_send_to(basic_raw_socket* self)
method executor_type (line 1105) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1129) | class initiate_async_receive
method initiate_async_receive (line 1134) | explicit initiate_async_receive(basic_raw_socket* self)
method executor_type (line 1139) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_from (line 1163) | class initiate_async_receive_from
method initiate_async_receive_from (line 1168) | explicit initiate_async_receive_from(basic_raw_socket* self)
method executor_type (line 1173) | executor_type get_executor() const ASIO_NOEXCEPT
class basic_raw_socket (line 50) | class basic_raw_socket
type rebind_executor (line 59) | struct rebind_executor
method basic_raw_socket (line 87) | explicit basic_raw_socket(const executor_type& ex)
method basic_raw_socket (line 102) | explicit basic_raw_socket(ExecutionContext& context,
method basic_raw_socket (line 121) | basic_raw_socket(const executor_type& ex, const protocol_type& proto...
method basic_raw_socket (line 139) | basic_raw_socket(ExecutionContext& context, const protocol_type& pro...
method basic_raw_socket (line 162) | basic_raw_socket(const executor_type& ex, const endpoint_type& endpo...
method basic_raw_socket (line 184) | basic_raw_socket(ExecutionContext& context, const endpoint_type& end...
method basic_raw_socket (line 206) | basic_raw_socket(const executor_type& ex,
method basic_raw_socket (line 228) | basic_raw_socket(ExecutionContext& context,
method basic_raw_socket (line 249) | basic_raw_socket(basic_raw_socket&& other) ASIO_NOEXCEPT
method basic_raw_socket (line 265) | basic_raw_socket& operator=(basic_raw_socket&& other)
method basic_raw_socket (line 284) | basic_raw_socket(basic_raw_socket<Protocol1, Executor1>&& other,
method send (line 347) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 373) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 400) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 444) | WriteHandler
method WriteHandler (line 488) | WriteHandler
method send_to (line 528) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 555) | std::size_t send_to(const ConstBufferSequence& buffers,
method send_to (line 582) | std::size_t send_to(const ConstBufferSequence& buffers,
method WriteHandler (line 629) | WriteHandler
method WriteHandler (line 673) | WriteHandler
method receive (line 712) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 740) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 769) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 814) | ReadHandler
method ReadHandler (line 858) | ReadHandler
method receive_from (line 899) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 926) | std::size_t receive_from(const MutableBufferSequence& buffers,
method receive_from (line 953) | std::size_t receive_from(const MutableBufferSequence& buffers,
method ReadHandler (line 999) | ReadHandler
method ReadHandler (line 1045) | ReadHandler
class initiate_async_send (line 1061) | class initiate_async_send
method initiate_async_send (line 1066) | explicit initiate_async_send(basic_raw_socket* self)
method executor_type (line 1071) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_send_to (line 1095) | class initiate_async_send_to
method initiate_async_send_to (line 1100) | explicit initiate_async_send_to(basic_raw_socket* self)
method executor_type (line 1105) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1129) | class initiate_async_receive
method initiate_async_receive (line 1134) | explicit initiate_async_receive(basic_raw_socket* self)
method executor_type (line 1139) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_from (line 1163) | class initiate_async_receive_from
method initiate_async_receive_from (line 1168) | explicit initiate_async_receive_from(basic_raw_socket* self)
method executor_type (line 1173) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_seq_packet_socket.hpp
type asio (line 27) | namespace asio {
class basic_seq_packet_socket (line 34) | class basic_seq_packet_socket
type rebind_executor (line 57) | struct rebind_executor
method basic_seq_packet_socket (line 86) | explicit basic_seq_packet_socket(const executor_type& ex)
method basic_seq_packet_socket (line 102) | explicit basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 123) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 144) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 168) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 191) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 214) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 236) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 258) | basic_seq_packet_socket(basic_seq_packet_socket&& other) ASIO_NOEXCEPT
method basic_seq_packet_socket (line 275) | basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
method basic_seq_packet_socket (line 295) | basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1...
method send (line 362) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 391) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 433) | WriteHandler
method receive (line 477) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 523) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 558) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 606) | ReadHandler
method ReadHandler (line 665) | ReadHandler
class initiate_async_send (line 682) | class initiate_async_send
method initiate_async_send (line 687) | explicit initiate_async_send(basic_seq_packet_socket* self)
method executor_type (line 692) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_with_flags (line 716) | class initiate_async_receive_with_flags
method initiate_async_receive_with_flags (line 721) | explicit initiate_async_receive_with_flags(basic_seq_packet_socket...
method executor_type (line 726) | executor_type get_executor() const ASIO_NOEXCEPT
class basic_seq_packet_socket (line 48) | class basic_seq_packet_socket
type rebind_executor (line 57) | struct rebind_executor
method basic_seq_packet_socket (line 86) | explicit basic_seq_packet_socket(const executor_type& ex)
method basic_seq_packet_socket (line 102) | explicit basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 123) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 144) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 168) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 191) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 214) | basic_seq_packet_socket(const executor_type& ex,
method basic_seq_packet_socket (line 236) | basic_seq_packet_socket(ExecutionContext& context,
method basic_seq_packet_socket (line 258) | basic_seq_packet_socket(basic_seq_packet_socket&& other) ASIO_NOEXCEPT
method basic_seq_packet_socket (line 275) | basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
method basic_seq_packet_socket (line 295) | basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1...
method send (line 362) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 391) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 433) | WriteHandler
method receive (line 477) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 523) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 558) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 606) | ReadHandler
method ReadHandler (line 665) | ReadHandler
class initiate_async_send (line 682) | class initiate_async_send
method initiate_async_send (line 687) | explicit initiate_async_send(basic_seq_packet_socket* self)
method executor_type (line 692) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive_with_flags (line 716) | class initiate_async_receive_with_flags
method initiate_async_receive_with_flags (line 721) | explicit initiate_async_receive_with_flags(basic_seq_packet_socket...
method executor_type (line 726) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_serial_port.hpp
type asio (line 47) | namespace asio {
class basic_serial_port (line 59) | class basic_serial_port
type rebind_executor (line 68) | struct rebind_executor
method basic_serial_port (line 96) | explicit basic_serial_port(const executor_type& ex)
method basic_serial_port (line 110) | explicit basic_serial_port(ExecutionContext& context,
method basic_serial_port (line 131) | basic_serial_port(const executor_type& ex, const char* device)
method basic_serial_port (line 152) | basic_serial_port(ExecutionContext& context, const char* device,
method basic_serial_port (line 175) | basic_serial_port(const executor_type& ex, const std::string& device)
method basic_serial_port (line 196) | basic_serial_port(ExecutionContext& context, const std::string& device,
method basic_serial_port (line 220) | basic_serial_port(const executor_type& ex,
method basic_serial_port (line 244) | basic_serial_port(ExecutionContext& context,
method basic_serial_port (line 269) | basic_serial_port(basic_serial_port&& other)
method basic_serial_port (line 285) | basic_serial_port& operator=(basic_serial_port&& other)
method executor_type (line 303) | executor_type get_executor() ASIO_NOEXCEPT
method lowest_layer_type (line 317) | lowest_layer_type& lowest_layer()
method lowest_layer_type (line 331) | const lowest_layer_type& lowest_layer() const
method open (line 344) | void open(const std::string& device)
method ASIO_SYNC_OP_VOID (line 360) | ASIO_SYNC_OP_VOID open(const std::string& device,
method assign (line 375) | void assign(const native_handle_type& native_serial_port)
method ASIO_SYNC_OP_VOID (line 391) | ASIO_SYNC_OP_VOID assign(const native_handle_type& native_serial_port,
method is_open (line 400) | bool is_open() const
method close (line 413) | void close()
method ASIO_SYNC_OP_VOID (line 428) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
method native_handle_type (line 440) | native_handle_type native_handle()
method cancel (line 453) | void cancel()
method ASIO_SYNC_OP_VOID (line 468) | ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
method send_break (line 481) | void send_break()
method ASIO_SYNC_OP_VOID (line 495) | ASIO_SYNC_OP_VOID send_break(asio::error_code& ec)
method set_option (line 517) | void set_option(const SettableSerialPortOption& option)
method ASIO_SYNC_OP_VOID (line 540) | ASIO_SYNC_OP_VOID set_option(const SettableSerialPortOption& option,
method get_option (line 564) | void get_option(GettableSerialPortOption& option) const
method ASIO_SYNC_OP_VOID (line 588) | ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
method write_some (line 623) | std::size_t write_some(const ConstBufferSequence& buffers)
method write_some (line 649) | std::size_t write_some(const ConstBufferSequence& buffers,
method WriteHandler (line 694) | WriteHandler
method read_some (line 736) | std::size_t read_some(const MutableBufferSequence& buffers)
method read_some (line 763) | std::size_t read_some(const MutableBufferSequence& buffers,
method ReadHandler (line 809) | ReadHandler
class initiate_async_write_some (line 827) | class initiate_async_write_some
method initiate_async_write_some (line 832) | explicit initiate_async_write_some(basic_serial_port* self)
method executor_type (line 837) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_read_some (line 860) | class initiate_async_read_some
method initiate_async_read_some (line 865) | explicit initiate_async_read_some(basic_serial_port* self)
method executor_type (line 870) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_signal_set.hpp
type asio (line 31) | namespace asio {
class basic_signal_set (line 94) | class basic_signal_set
type rebind_executor (line 102) | struct rebind_executor
method basic_signal_set (line 116) | explicit basic_signal_set(const executor_type& ex)
method basic_signal_set (line 130) | explicit basic_signal_set(ExecutionContext& context,
method basic_signal_set (line 152) | basic_signal_set(const executor_type& ex, int signal_number_1)
method basic_signal_set (line 175) | basic_signal_set(ExecutionContext& context, int signal_number_1,
method basic_signal_set (line 203) | basic_signal_set(const executor_type& ex, int signal_number_1,
method basic_signal_set (line 232) | basic_signal_set(ExecutionContext& context, int signal_number_1,
method basic_signal_set (line 266) | basic_signal_set(const executor_type& ex, int signal_number_1,
method basic_signal_set (line 300) | basic_signal_set(ExecutionContext& context, int signal_number_1,
method executor_type (line 327) | executor_type get_executor() ASIO_NOEXCEPT
method add (line 341) | void add(int signal_number)
method ASIO_SYNC_OP_VOID (line 357) | ASIO_SYNC_OP_VOID add(int signal_number,
method remove (line 376) | void remove(int signal_number)
method ASIO_SYNC_OP_VOID (line 395) | ASIO_SYNC_OP_VOID remove(int signal_number,
method clear (line 411) | void clear()
method ASIO_SYNC_OP_VOID (line 427) | ASIO_SYNC_OP_VOID clear(asio::error_code& ec)
method cancel (line 454) | void cancel()
method ASIO_SYNC_OP_VOID (line 482) | ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
method SignalHandler (line 515) | SignalHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
class initiate_async_wait (line 531) | class initiate_async_wait
method initiate_async_wait (line 536) | explicit initiate_async_wait(basic_signal_set* self)
method executor_type (line 541) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_socket.hpp
type asio (line 45) | namespace asio {
class basic_socket (line 52) | class basic_socket
type rebind_executor (line 75) | struct rebind_executor
function basic_socket (line 113) | explicit basic_socket(const executor_type& ex)
function basic_socket (line 127) | explicit basic_socket(ExecutionContext& context,
function basic_socket (line 146) | basic_socket(const executor_type& ex, const protocol_type& protocol)
function basic_socket (line 167) | basic_socket(ExecutionContext& context, const protocol_type& protocol,
function basic_socket (line 193) | basic_socket(const executor_type& ex, const endpoint_type& endpoint)
function basic_socket (line 221) | basic_socket(ExecutionContext& context, const endpoint_type& endpoint,
function basic_socket (line 248) | basic_socket(const executor_type& ex, const protocol_type& protocol,
function basic_socket (line 273) | basic_socket(ExecutionContext& context, const protocol_type& protocol,
function basic_socket (line 297) | basic_socket(basic_socket&& other) ASIO_NOEXCEPT
function basic_socket (line 312) | basic_socket& operator=(basic_socket&& other)
function basic_socket (line 333) | basic_socket(basic_socket<Protocol1, Executor1>&& other,
function executor_type (line 366) | executor_type get_executor() ASIO_NOEXCEPT
function lowest_layer_type (line 381) | lowest_layer_type& lowest_layer()
function lowest_layer_type (line 395) | const lowest_layer_type& lowest_layer() const
function open (line 415) | void open(const protocol_type& protocol = protocol_type())
function ASIO_SYNC_OP_VOID (line 441) | ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
function assign (line 458) | void assign(const protocol_type& protocol,
function ASIO_SYNC_OP_VOID (line 477) | ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
function is_open (line 486) | bool is_open() const
function close (line 503) | void close()
function ASIO_SYNC_OP_VOID (line 534) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
function native_handle_type (line 559) | native_handle_type release()
function native_handle_type (line 587) | native_handle_type release(asio::error_code& ec)
function native_handle_type (line 598) | native_handle_type native_handle()
function cancel (line 644) | void cancel()
function ASIO_SYNC_OP_VOID (line 692) | ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
function at_mark (line 708) | bool at_mark() const
function at_mark (line 726) | bool at_mark(asio::error_code& ec) const
function available (line 741) | std::size_t available() const
function available (line 760) | std::size_t available(asio::error_code& ec) const
function bind (line 783) | void bind(const endpoint_type& endpoint)
function ASIO_SYNC_OP_VOID (line 813) | ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
function connect (line 843) | void connect(const endpoint_type& peer_endpoint)
function ASIO_SYNC_OP_VOID (line 884) | ASIO_SYNC_OP_VOID connect(const endpoint_type& peer_endpoint,
function ConnectHandler (line 944) | ConnectHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
function set_option (line 997) | void set_option(const SettableSocketOption& option)
function ASIO_SYNC_OP_VOID (line 1044) | ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
function get_option (line 1087) | void get_option(GettableSocketOption& option) const
function ASIO_SYNC_OP_VOID (line 1135) | ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
function io_control (line 1165) | void io_control(IoControlCommand& command)
function ASIO_SYNC_OP_VOID (line 1200) | ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
function non_blocking (line 1218) | bool non_blocking() const
function non_blocking (line 1236) | void non_blocking(bool mode)
function ASIO_SYNC_OP_VOID (line 1256) | ASIO_SYNC_OP_VOID non_blocking(
function native_non_blocking (line 1347) | bool native_non_blocking() const
function native_non_blocking (line 1437) | void native_non_blocking(bool mode)
function ASIO_SYNC_OP_VOID (line 1530) | ASIO_SYNC_OP_VOID native_non_blocking(
function endpoint_type (line 1553) | endpoint_type local_endpoint() const
function endpoint_type (line 1583) | endpoint_type local_endpoint(asio::error_code& ec) const
function endpoint_type (line 1603) | endpoint_type remote_endpoint() const
function endpoint_type (line 1633) | endpoint_type remote_endpoint(asio::error_code& ec) const
function shutdown (line 1655) | void shutdown(shutdown_type what)
function ASIO_SYNC_OP_VOID (line 1684) | ASIO_SYNC_OP_VOID shutdown(shutdown_type what,
function wait (line 1707) | void wait(wait_type w)
function ASIO_SYNC_OP_VOID (line 1733) | ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
function WaitHandler (line 1777) | WaitHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
class initiate_async_connect (line 1814) | class initiate_async_connect
method initiate_async_connect (line 1819) | explicit initiate_async_connect(basic_socket* self)
method executor_type (line 1824) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_wait (line 1857) | class initiate_async_wait
method initiate_async_wait (line 1862) | explicit initiate_async_wait(basic_socket* self)
method executor_type (line 1867) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_socket_acceptor.hpp
type asio (line 44) | namespace asio {
class basic_socket_acceptor (line 51) | class basic_socket_acceptor
type rebind_executor (line 85) | struct rebind_executor
function basic_socket_acceptor (line 121) | explicit basic_socket_acceptor(const executor_type& ex)
function basic_socket_acceptor (line 137) | explicit basic_socket_acceptor(ExecutionContext& context,
function basic_socket_acceptor (line 157) | basic_socket_acceptor(const executor_type& ex, const protocol_type& pr...
function basic_socket_acceptor (line 178) | basic_socket_acceptor(ExecutionContext& context,
function basic_socket_acceptor (line 217) | basic_socket_acceptor(const executor_type& ex,
function basic_socket_acceptor (line 266) | basic_socket_acceptor(ExecutionContext& context,
function basic_socket_acceptor (line 305) | basic_socket_acceptor(const executor_type& ex,
function basic_socket_acceptor (line 331) | basic_socket_acceptor(ExecutionContext& context,
function basic_socket_acceptor (line 356) | basic_socket_acceptor(basic_socket_acceptor&& other)
function basic_socket_acceptor (line 372) | basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
function basic_socket_acceptor (line 395) | basic_socket_acceptor(basic_socket_acceptor<Protocol1, Executor1>&& ot...
function executor_type (line 440) | executor_type get_executor() ASIO_NOEXCEPT
function open (line 460) | void open(const protocol_type& protocol = protocol_type())
function ASIO_SYNC_OP_VOID (line 487) | ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
function assign (line 504) | void assign(const protocol_type& protocol,
function ASIO_SYNC_OP_VOID (line 523) | ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
function is_open (line 532) | bool is_open() const
function bind (line 555) | void bind(const endpoint_type& endpoint)
function ASIO_SYNC_OP_VOID (line 585) | ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
function listen (line 602) | void listen(int backlog = socket_base::max_listen_connections)
function ASIO_SYNC_OP_VOID (line 631) | ASIO_SYNC_OP_VOID listen(int backlog, asio::error_code& ec)
function close (line 647) | void close()
function ASIO_SYNC_OP_VOID (line 676) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
function native_handle_type (line 701) | native_handle_type release()
function native_handle_type (line 729) | native_handle_type release(asio::error_code& ec)
function native_handle_type (line 740) | native_handle_type native_handle()
function cancel (line 753) | void cancel()
function ASIO_SYNC_OP_VOID (line 768) | ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
function set_option (line 796) | void set_option(const SettableSocketOption& option)
function ASIO_SYNC_OP_VOID (line 830) | ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
function get_option (line 860) | void get_option(GettableSocketOption& option) const
function ASIO_SYNC_OP_VOID (line 895) | ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
function io_control (line 923) | void io_control(IoControlCommand& command)
function ASIO_SYNC_OP_VOID (line 956) | ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
function non_blocking (line 974) | bool non_blocking() const
function non_blocking (line 992) | void non_blocking(bool mode)
function ASIO_SYNC_OP_VOID (line 1012) | ASIO_SYNC_OP_VOID non_blocking(
function native_non_blocking (line 1033) | bool native_non_blocking() const
function native_non_blocking (line 1053) | void native_non_blocking(bool mode)
function ASIO_SYNC_OP_VOID (line 1076) | ASIO_SYNC_OP_VOID native_non_blocking(
function endpoint_type (line 1099) | endpoint_type local_endpoint() const
function endpoint_type (line 1130) | endpoint_type local_endpoint(asio::error_code& ec) const
function wait (line 1151) | void wait(wait_type w)
function ASIO_SYNC_OP_VOID (line 1177) | ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
function WaitHandler (line 1223) | WaitHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
function accept (line 1254) | void accept(basic_socket<Protocol1, Executor1>& peer,
function ASIO_SYNC_OP_VOID (line 1289) | ASIO_SYNC_OP_VOID accept(
function AcceptHandler (line 1340) | AcceptHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
function accept (line 1379) | void accept(basic_socket<protocol_type, Executor1>& peer,
function ASIO_SYNC_OP_VOID (line 1417) | ASIO_SYNC_OP_VOID accept(basic_socket<protocol_type, Executor1>& peer,
function AcceptHandler (line 1453) | AcceptHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
function accept (line 1487) | typename Protocol::socket::template rebind_executor<executor_type>::other
function accept (line 1523) | typename Protocol::socket::template rebind_executor<executor_type>::other
function accept (line 1619) | typename Protocol::socket::template rebind_executor<Executor1>::other
function accept (line 1657) | typename Protocol::socket::template rebind_executor<
function accept (line 1701) | typename Protocol::socket::template rebind_executor<Executor1>::other
function accept (line 1742) | typename Protocol::socket::template rebind_executor<
function async_accept (line 1806) | async_accept(const Executor1& ex,
function async_accept (line 1875) | async_accept(ExecutionContext& context,
function accept (line 1916) | typename Protocol::socket::template rebind_executor<executor_type>::other
function accept (line 1957) | typename Protocol::socket::template rebind_executor<executor_type>::other
function async_accept (line 2023) | async_accept(endpoint_type& peer_endpoint,
function accept (line 2065) | typename Protocol::socket::template rebind_executor<Executor1>::other
function accept (line 2109) | typename Protocol::socket::template rebind_executor<
function accept (line 2159) | typename Protocol::socket::template rebind_executor<Executor1>::other
function accept (line 2207) | typename Protocol::socket::template rebind_executor<
function async_accept (line 2279) | async_accept(const Executor1& ex, endpoint_type& peer_endpoint,
function async_accept (line 2354) | async_accept(ExecutionContext& context,
class initiate_async_wait (line 2379) | class initiate_async_wait
method initiate_async_wait (line 2384) | explicit initiate_async_wait(basic_socket_acceptor* self)
method executor_type (line 2389) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_accept (line 2411) | class initiate_async_accept
method initiate_async_accept (line 2416) | explicit initiate_async_accept(basic_socket_acceptor* self)
method executor_type (line 2421) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_move_accept (line 2445) | class initiate_async_move_accept
method initiate_async_move_accept (line 2450) | explicit initiate_async_move_accept(basic_socket_acceptor* self)
method executor_type (line 2455) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_socket_iostream.hpp
type detail (line 78) | namespace detail {
class socket_iostream_base (line 83) | class socket_iostream_base
method socket_iostream_base (line 86) | socket_iostream_base()
method socket_iostream_base (line 91) | socket_iostream_base(socket_iostream_base&& other)
method socket_iostream_base (line 96) | socket_iostream_base(basic_stream_socket<Protocol> s)
method socket_iostream_base (line 101) | socket_iostream_base& operator=(socket_iostream_base&& other)
class basic_socket_iostream (line 140) | class basic_socket_iostream
method basic_socket_iostream (line 188) | basic_socket_iostream()
method basic_socket_iostream (line 198) | explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
method basic_socket_iostream (line 211) | basic_socket_iostream(basic_socket_iostream&& other)
method basic_socket_iostream (line 221) | basic_socket_iostream& operator=(basic_socket_iostream&& other)
method basic_socket_iostream (line 243) | explicit basic_socket_iostream(T... x)
method connect (line 267) | void connect(T... x)
method close (line 277) | void close()
method time_point (line 320) | time_point expires_at() const
method time_point (line 330) | time_point expiry() const
method expires_at (line 344) | void expires_at(const time_point& expiry_time)
method expires_after (line 358) | void expires_after(const duration& expiry_time)
method duration (line 368) | duration expires_from_now() const
method expires_from_now (line 383) | void expires_from_now(const duration& expiry_time)
FILE: src/third_party/asio/basic_socket_streambuf.hpp
type detail (line 75) | namespace detail {
class socket_streambuf_io_context (line 79) | class socket_streambuf_io_context
method socket_streambuf_io_context (line 82) | socket_streambuf_io_context(io_context* ctx)
class socket_streambuf_buffers (line 95) | class socket_streambuf_buffers
method socket_streambuf_buffers (line 98) | socket_streambuf_buffers()
class basic_socket_streambuf (line 138) | class basic_socket_streambuf
method basic_socket_streambuf (line 192) | basic_socket_streambuf()
method basic_socket_streambuf (line 202) | explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
method basic_socket_streambuf (line 211) | basic_socket_streambuf(basic_socket_streambuf&& other)
method basic_socket_streambuf (line 227) | basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
method basic_socket_streambuf (line 260) | basic_socket_streambuf* connect(const endpoint_type& endpoint)
method basic_socket_streambuf (line 282) | basic_socket_streambuf* connect(T... x)
method basic_socket_streambuf (line 299) | basic_socket_streambuf* close()
method time_point (line 342) | time_point expires_at() const
method time_point (line 353) | time_point expiry() const
method expires_at (line 367) | void expires_at(const time_point& expiry_time)
method expires_after (line 381) | void expires_after(const duration& expiry_time)
method duration (line 392) | duration expires_from_now() const
method expires_from_now (line 407) | void expires_from_now(const duration& expiry_time)
method int_type (line 414) | int_type underflow()
method int_type (line 468) | int_type overflow(int_type c)
method sync (line 542) | int sync()
method init_buffers (line 566) | void init_buffers()
method timeout (line 578) | int timeout() const
method connect_to_endpoints (line 591) | void connect_to_endpoints(const EndpointSequence& endpoints)
method connect_to_endpoints (line 597) | void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
method time_point (line 660) | static time_point max_expiry_time()
FILE: src/third_party/asio/basic_stream_socket.hpp
type asio (line 29) | namespace asio {
class basic_stream_socket (line 36) | class basic_stream_socket
type rebind_executor (line 62) | struct rebind_executor
method basic_stream_socket (line 91) | explicit basic_stream_socket(const executor_type& ex)
method basic_stream_socket (line 107) | explicit basic_stream_socket(ExecutionContext& context,
method basic_stream_socket (line 127) | basic_stream_socket(const executor_type& ex, const protocol_type& pr...
method basic_stream_socket (line 146) | basic_stream_socket(ExecutionContext& context, const protocol_type& ...
method basic_stream_socket (line 169) | basic_stream_socket(const executor_type& ex, const endpoint_type& en...
method basic_stream_socket (line 191) | basic_stream_socket(ExecutionContext& context, const endpoint_type& ...
method basic_stream_socket (line 213) | basic_stream_socket(const executor_type& ex,
method basic_stream_socket (line 235) | basic_stream_socket(ExecutionContext& context,
method basic_stream_socket (line 256) | basic_stream_socket(basic_stream_socket&& other) ASIO_NOEXCEPT
method basic_stream_socket (line 272) | basic_stream_socket& operator=(basic_stream_socket&& other)
method basic_stream_socket (line 291) | basic_stream_socket(basic_stream_socket<Protocol1, Executor1>&& other,
method send (line 358) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 395) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 424) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 468) | WriteHandler
method WriteHandler (line 521) | WriteHandler
method receive (line 564) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 604) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 633) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 679) | ReadHandler
method ReadHandler (line 734) | ReadHandler
method write_some (line 776) | std::size_t write_some(const ConstBufferSequence& buffers)
method write_some (line 802) | std::size_t write_some(const ConstBufferSequence& buffers,
method WriteHandler (line 846) | WriteHandler
method read_some (line 889) | std::size_t read_some(const MutableBufferSequence& buffers)
method read_some (line 916) | std::size_t read_some(const MutableBufferSequence& buffers,
method ReadHandler (line 961) | ReadHandler
class initiate_async_send (line 976) | class initiate_async_send
method initiate_async_send (line 981) | explicit initiate_async_send(basic_stream_socket* self)
method executor_type (line 986) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1010) | class initiate_async_receive
method initiate_async_receive (line 1015) | explicit initiate_async_receive(basic_stream_socket* self)
method executor_type (line 1020) | executor_type get_executor() const ASIO_NOEXCEPT
class basic_stream_socket (line 53) | class basic_stream_socket
type rebind_executor (line 62) | struct rebind_executor
method basic_stream_socket (line 91) | explicit basic_stream_socket(const executor_type& ex)
method basic_stream_socket (line 107) | explicit basic_stream_socket(ExecutionContext& context,
method basic_stream_socket (line 127) | basic_stream_socket(const executor_type& ex, const protocol_type& pr...
method basic_stream_socket (line 146) | basic_stream_socket(ExecutionContext& context, const protocol_type& ...
method basic_stream_socket (line 169) | basic_stream_socket(const executor_type& ex, const endpoint_type& en...
method basic_stream_socket (line 191) | basic_stream_socket(ExecutionContext& context, const endpoint_type& ...
method basic_stream_socket (line 213) | basic_stream_socket(const executor_type& ex,
method basic_stream_socket (line 235) | basic_stream_socket(ExecutionContext& context,
method basic_stream_socket (line 256) | basic_stream_socket(basic_stream_socket&& other) ASIO_NOEXCEPT
method basic_stream_socket (line 272) | basic_stream_socket& operator=(basic_stream_socket&& other)
method basic_stream_socket (line 291) | basic_stream_socket(basic_stream_socket<Protocol1, Executor1>&& other,
method send (line 358) | std::size_t send(const ConstBufferSequence& buffers)
method send (line 395) | std::size_t send(const ConstBufferSequence& buffers,
method send (line 424) | std::size_t send(const ConstBufferSequence& buffers,
method WriteHandler (line 468) | WriteHandler
method WriteHandler (line 521) | WriteHandler
method receive (line 564) | std::size_t receive(const MutableBufferSequence& buffers)
method receive (line 604) | std::size_t receive(const MutableBufferSequence& buffers,
method receive (line 633) | std::size_t receive(const MutableBufferSequence& buffers,
method ReadHandler (line 679) | ReadHandler
method ReadHandler (line 734) | ReadHandler
method write_some (line 776) | std::size_t write_some(const ConstBufferSequence& buffers)
method write_some (line 802) | std::size_t write_some(const ConstBufferSequence& buffers,
method WriteHandler (line 846) | WriteHandler
method read_some (line 889) | std::size_t read_some(const MutableBufferSequence& buffers)
method read_some (line 916) | std::size_t read_some(const MutableBufferSequence& buffers,
method ReadHandler (line 961) | ReadHandler
class initiate_async_send (line 976) | class initiate_async_send
method initiate_async_send (line 981) | explicit initiate_async_send(basic_stream_socket* self)
method executor_type (line 986) | executor_type get_executor() const ASIO_NOEXCEPT
class initiate_async_receive (line 1010) | class initiate_async_receive
method initiate_async_receive (line 1015) | explicit initiate_async_receive(basic_stream_socket* self)
method executor_type (line 1020) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/basic_streambuf.hpp
class basic_streambuf (line 110) | class basic_streambuf
method basic_streambuf (line 131) | explicit basic_streambuf(
method max_size (line 168) | std::size_t max_size() const ASIO_NOEXCEPT
method capacity (line 178) | std::size_t capacity() const ASIO_NOEXCEPT
method const_buffers_type (line 192) | const_buffers_type data() const ASIO_NOEXCEPT
method mutable_buffers_type (line 214) | mutable_buffers_type prepare(std::size_t n)
method commit (line 233) | void commit(std::size_t n)
method consume (line 247) | void consume(std::size_t n)
method int_type (line 263) | int_type underflow()
method int_type (line 283) | int_type overflow(int_type c)
method reserve (line 308) | void reserve(std::size_t n)
method read_size_helper (line 353) | std::size_t read_size_helper(
class basic_streambuf_ref (line 368) | class basic_streambuf_ref
method basic_streambuf_ref (line 380) | explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
method basic_streambuf_ref (line 386) | basic_streambuf_ref(const basic_streambuf_ref& other) ASIO_NOEXCEPT
method basic_streambuf_ref (line 393) | basic_streambuf_ref(basic_streambuf_ref&& other) ASIO_NOEXCEPT
method max_size (line 406) | std::size_t max_size() const ASIO_NOEXCEPT
method capacity (line 412) | std::size_t capacity() const ASIO_NOEXCEPT
method const_buffers_type (line 418) | const_buffers_type data() const ASIO_NOEXCEPT
method mutable_buffers_type (line 425) | mutable_buffers_type prepare(std::size_t n)
method commit (line 431) | void commit(std::size_t n)
method consume (line 437) | void consume(std::size_t n)
FILE: src/third_party/asio/basic_streambuf_fwd.hpp
type asio (line 24) | namespace asio {
class basic_streambuf (line 27) | class basic_streambuf
class basic_streambuf_ref (line 30) | class basic_streambuf_ref
FILE: src/third_party/asio/basic_waitable_timer.hpp
type asio (line 36) | namespace asio {
class basic_waitable_timer (line 45) | class basic_waitable_timer
type rebind_executor (line 150) | struct rebind_executor
method basic_waitable_timer (line 177) | explicit basic_waitable_timer(const executor_type& ex)
method basic_waitable_timer (line 193) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 211) | basic_waitable_timer(const executor_type& ex, const time_point& expi...
method basic_waitable_timer (line 231) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 253) | basic_waitable_timer(const executor_type& ex, const duration& expiry...
method basic_waitable_timer (line 274) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 299) | basic_waitable_timer(basic_waitable_timer&& other)
method basic_waitable_timer (line 316) | basic_waitable_timer& operator=(basic_waitable_timer&& other)
method executor_type (line 333) | executor_type get_executor() ASIO_NOEXCEPT
method cancel (line 360) | std::size_t cancel()
method cancel (line 392) | std::size_t cancel(asio::error_code& ec)
method cancel_one (line 422) | std::size_t cancel_one()
method cancel_one (line 457) | std::size_t cancel_one(asio::error_code& ec)
method time_point (line 468) | time_point expires_at() const
method time_point (line 479) | time_point expiry() const
method expires_at (line 506) | std::size_t expires_at(const time_point& expiry_time)
method expires_at (line 539) | std::size_t expires_at(const time_point& expiry_time,
method expires_after (line 569) | std::size_t expires_after(const duration& expiry_time)
method duration (line 584) | duration expires_from_now() const
method expires_from_now (line 612) | std::size_t expires_from_now(const duration& expiry_time)
method expires_from_now (line 644) | std::size_t expires_from_now(const duration& expiry_time,
method wait (line 659) | void wait()
method wait (line 673) | void wait(asio::error_code& ec)
method WaitHandler (line 704) | WaitHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
class initiate_async_wait (line 721) | class initiate_async_wait
method initiate_async_wait (line 726) | explicit initiate_async_wait(basic_waitable_timer* self)
method executor_type (line 731) | executor_type get_executor() const ASIO_NOEXCEPT
class basic_waitable_timer (line 142) | class basic_waitable_timer
type rebind_executor (line 150) | struct rebind_executor
method basic_waitable_timer (line 177) | explicit basic_waitable_timer(const executor_type& ex)
method basic_waitable_timer (line 193) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 211) | basic_waitable_timer(const executor_type& ex, const time_point& expi...
method basic_waitable_timer (line 231) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 253) | basic_waitable_timer(const executor_type& ex, const duration& expiry...
method basic_waitable_timer (line 274) | explicit basic_waitable_timer(ExecutionContext& context,
method basic_waitable_timer (line 299) | basic_waitable_timer(basic_waitable_timer&& other)
method basic_waitable_timer (line 316) | basic_waitable_timer& operator=(basic_waitable_timer&& other)
method executor_type (line 333) | executor_type get_executor() ASIO_NOEXCEPT
method cancel (line 360) | std::size_t cancel()
method cancel (line 392) | std::size_t cancel(asio::error_code& ec)
method cancel_one (line 422) | std::size_t cancel_one()
method cancel_one (line 457) | std::size_t cancel_one(asio::error_code& ec)
method time_point (line 468) | time_point expires_at() const
method time_point (line 479) | time_point expiry() const
method expires_at (line 506) | std::size_t expires_at(const time_point& expiry_time)
method expires_at (line 539) | std::size_t expires_at(const time_point& expiry_time,
method expires_after (line 569) | std::size_t expires_after(const duration& expiry_time)
method duration (line 584) | duration expires_from_now() const
method expires_from_now (line 612) | std::size_t expires_from_now(const duration& expiry_time)
method expires_from_now (line 644) | std::size_t expires_from_now(const duration& expiry_time,
method wait (line 659) | void wait()
method wait (line 673) | void wait(asio::error_code& ec)
method WaitHandler (line 704) | WaitHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
class initiate_async_wait (line 721) | class initiate_async_wait
method initiate_async_wait (line 726) | explicit initiate_async_wait(basic_waitable_timer* self)
method executor_type (line 731) | executor_type get_executor() const ASIO_NOEXCEPT
FILE: src/third_party/asio/bind_executor.hpp
type asio (line 30) | namespace asio {
type detail (line 31) | namespace detail {
type executor_binder_check (line 34) | struct executor_binder_check
type executor_binder_result_type (line 42) | struct executor_binder_result_type
type executor_binder_result_type<T,
typename executor_binder_check<typename T::result_type>::type> (line 49) | struct executor_binder_result_type<T,
type executor_binder_result_type<R(*)()> (line 58) | struct executor_binder_result_type<R(*)()>
type executor_binder_result_type<R(&)()> (line 66) | struct executor_binder_result_type<R(&)()>
type executor_binder_result_type<R(*)(A1)> (line 74) | struct executor_binder_result_type<R(*)(A1)>
type executor_binder_result_type<R(&)(A1)> (line 82) | struct executor_binder_result_type<R(&)(A1)>
type executor_binder_result_type<R(*)(A1, A2)> (line 90) | struct executor_binder_result_type<R(*)(A1, A2)>
type executor_binder_result_type<R(&)(A1, A2)> (line 98) | struct executor_binder_result_type<R(&)(A1, A2)>
type executor_binder_argument_type (line 108) | struct executor_binder_argument_type {}
type executor_binder_argument_type<T,
typename executor_binder_check<typename T::argument_type>::type> (line 111) | struct executor_binder_argument_type<T,
type executor_binder_argument_type<R(*)(A1)> (line 118) | struct executor_binder_argument_type<R(*)(A1)>
type executor_binder_argument_type<R(&)(A1)> (line 124) | struct executor_binder_argument_type<R(&)(A1)>
type executor_binder_argument_types (line 133) | struct executor_binder_argument_types {}
type executor_binder_argument_types<T,
typename executor_binder_check<typename T::first_argument_type>::type> (line 136) | struct executor_binder_argument_types<T,
type executor_binder_argument_type<R(*)(A1, A2)> (line 144) | struct executor_binder_argument_type<R(*)(A1, A2)>
type executor_binder_argument_type<R(&)(A1, A2)> (line 151) | struct executor_binder_argument_type<R(&)(A1, A2)>
class executor_binder_base (line 162) | class executor_binder_base
class executor_binder_base<T, Executor, true> (line 165) | class executor_binder_base<T, Executor, true>
method executor_binder_base (line 170) | executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
class executor_binder_base<T, Executor, false> (line 181) | class executor_binder_base<T, Executor, false>
method executor_binder_base (line 185) | executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
type executor_binder_result_of0 (line 198) | struct executor_binder_result_of0
type executor_binder_result_of0<T,
typename executor_binder_check<typename result_of<T()>::type>::type> (line 204) | struct executor_binder_result_of0<T,
class executor_binder (line 215) | class executor_binder
function executor_binder (line 299) | executor_binder(executor_arg_t, const executor_type& e,
function executor_binder (line 306) | executor_binder(const executor_binder& other)
function executor_binder (line 312) | executor_binder(executor_arg_t, const executor_type& e,
function executor_binder (line 325) | executor_binder(const executor_binder<U, OtherExecutor>& other)
function executor_binder (line 337) | executor_binder(executor_arg_t, const executor_type& e,
function executor_binder (line 346) | executor_binder(executor_binder&& other)
function executor_binder (line 353) | executor_binder(executor_arg_t, const executor_type& e,
function executor_binder (line 361) | executor_binder(executor_binder<U, OtherExecutor>&& other)
function executor_binder (line 370) | executor_binder(executor_arg_t, const executor_type& e,
function target_type (line 390) | const target_type& get() const ASIO_NOEXCEPT
function executor_type (line 396) | executor_type get_executor() const ASIO_NOEXCEPT
function result_type_or_void (line 459) | result_type_or_void operator()()
function result_type_or_void (line 464) | result_type_or_void operator()() const
function bind_executor (line 496) | inline executor_binder<typename decay<T>::type, Executor>
function bind_executor (line 506) | inline executor_binder<typename decay<T>::type,
type uses_executor<executor_binder<T, Executor>, Executor> (line 520) | struct uses_executor<executor_binder<T, Executor>, Executor>
class async_result<executor_binder<T, Executor>, Signature> (line 524) | class async_result<executor_binder<T, Executor>, Signature>
method async_result (line 533) | explicit async_result(executor_binder<T, Executor>& b)
method return_type (line 538) | return_type get()
type associated_allocator<executor_binder<T, Executor>, Allocator> (line 551) | struct associated_allocator<executor_binder<T, Executor>, Allocator>
method type (line 555) | static type get(const executor_binder<T, Executor>& b,
type associated_executor<executor_binder<T, Executor>, Executor1> (line 563) | struct associated_executor<executor_binder<T, Executor>, Executor1>
method type (line 567) | static type get(const executor_binder<T, Executor>& b,
FILE: src/third_party/asio/buffer.hpp
type asio (line 66) | namespace asio {
class mutable_buffer (line 68) | class mutable_buffer
method mutable_buffer (line 94) | mutable_buffer() ASIO_NOEXCEPT
method mutable_buffer (line 101) | mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffer (line 108) | mutable_buffer(void* data, std::size_t size,
method mutable_buffer (line 139) | mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
class const_buffer (line 69) | class const_buffer
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
class mutable_buffer (line 90) | class mutable_buffer
method mutable_buffer (line 94) | mutable_buffer() ASIO_NOEXCEPT
method mutable_buffer (line 101) | mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffer (line 108) | mutable_buffer(void* data, std::size_t size,
method mutable_buffer (line 139) | mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
class mutable_buffers_1 (line 160) | class mutable_buffers_1
method mutable_buffers_1 (line 171) | mutable_buffers_1(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffers_1 (line 177) | mutable_buffers_1(void* data, std::size_t size,
method mutable_buffers_1 (line 185) | explicit mutable_buffers_1(const mutable_buffer& b) ASIO_NOEXCEPT
method const_iterator (line 191) | const_iterator begin() const ASIO_NOEXCEPT
method const_iterator (line 197) | const_iterator end() const ASIO_NOEXCEPT
class const_buffer (line 224) | class const_buffer
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
function const_buffer (line 252) | const_buffer(const void* data, std::size_t size,
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
function ASIO_NOEXCEPT (line 277) | std::size_t size() const ASIO_NOEXCEPT
function const_buffer (line 283) | const_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
class const_buffers_1 (line 304) | class const_buffers_1
method const_buffers_1 (line 315) | const_buffers_1(const void* data, std::size_t size) ASIO_NOEXCEPT
method const_buffers_1 (line 321) | const_buffers_1(const void* data, std::size_t size,
method const_buffers_1 (line 329) | explicit const_buffers_1(const const_buffer& b) ASIO_NOEXCEPT
method const_iterator (line 335) | const_iterator begin() const ASIO_NOEXCEPT
method const_iterator (line 341) | const_iterator end() const ASIO_NOEXCEPT
class null_buffers (line 352) | class null_buffers
method const_iterator (line 362) | const_iterator begin() const ASIO_NOEXCEPT
method const_iterator (line 368) | const_iterator end() const ASIO_NOEXCEPT
function mutable_buffer (line 386) | inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
function const_buffer (line 396) | inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
function buffer_sequence_begin (line 408) | inline auto buffer_sequence_begin(C& c,
function buffer_sequence_begin (line 419) | inline auto buffer_sequence_begin(const C& c,
function buffer_sequence_begin (line 431) | inline typename C::iterator buffer_sequence_begin(C& c,
function buffer_sequence_begin (line 441) | inline typename C::const_iterator buffer_sequence_begin(const C& c,
function mutable_buffer (line 463) | inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
function const_buffer (line 473) | inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
function buffer_sequence_end (line 485) | inline auto buffer_sequence_end(C& c,
function buffer_sequence_end (line 496) | inline auto buffer_sequence_end(const C& c,
function buffer_sequence_end (line 508) | inline typename C::iterator buffer_sequence_end(C& c,
function buffer_sequence_end (line 518) | inline typename C::const_iterator buffer_sequence_end(const C& c,
type detail (line 531) | namespace detail {
type one_buffer (line 534) | struct one_buffer {}
type multiple_buffers (line 535) | struct multiple_buffers {}
type buffer_sequence_cardinality (line 539) | struct buffer_sequence_cardinality :
function buffer_size (line 550) | inline std::size_t buffer_size(one_buffer,
function buffer_size (line 557) | inline std::size_t buffer_size(multiple_buffers,
class buffer_debug_check (line 702) | class buffer_debug_check
method buffer_debug_check (line 705) | buffer_debug_check(Iterator iter)
type buffer_types_base (line 1058) | struct buffer_types_base
type buffer_types_base<false> (line 1061) | struct buffer_types_base<false>
type buffer_types_base<true> (line 1068) | struct buffer_types_base<true>
type buffer_types (line 1075) | struct buffer_types
function buffer_size (line 593) | inline std::size_t buffer_size(const BufferSequence& b) ASIO_NOEXCEPT
function PointerToPodType (line 628) | inline PointerToPodType buffer_cast(const mutable_buffer& b) ASIO_NOEXCEPT
function PointerToPodType (line 635) | inline PointerToPodType buffer_cast(const const_buffer& b) ASIO_NOEXCEPT
function mutable_buffer (line 648) | inline mutable_buffer operator+(const mutable_buffer& b,
function mutable_buffer (line 665) | inline mutable_buffer operator+(std::size_t n,
function const_buffer (line 675) | inline const_buffer operator+(const const_buffer& b,
function const_buffer (line 692) | inline const_buffer operator+(std::size_t n,
type detail (line 699) | namespace detail {
type one_buffer (line 534) | struct one_buffer {}
type multiple_buffers (line 535) | struct multiple_buffers {}
type buffer_sequence_cardinality (line 539) | struct buffer_sequence_cardinality :
function buffer_size (line 550) | inline std::size_t buffer_size(one_buffer,
function buffer_size (line 557) | inline std::size_t buffer_size(multiple_buffers,
class buffer_debug_check (line 702) | class buffer_debug_check
method buffer_debug_check (line 705) | buffer_debug_check(Iterator iter)
type buffer_types_base (line 1058) | struct buffer_types_base
type buffer_types_base<false> (line 1061) | struct buffer_types_base<false>
type buffer_types_base<true> (line 1068) | struct buffer_types_base<true>
type buffer_types (line 1075) | struct buffer_types
function ASIO_MUTABLE_BUFFER (line 907) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 920) | inline ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
function ASIO_CONST_BUFFER (line 937) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 950) | inline ASIO_CONST_BUFFER buffer(const const_buffer& b,
function ASIO_MUTABLE_BUFFER (line 966) | inline ASIO_MUTABLE_BUFFER buffer(void* data,
function ASIO_CONST_BUFFER (line 976) | inline ASIO_CONST_BUFFER buffer(const void* data,
function ASIO_MUTABLE_BUFFER (line 990) | inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) ASIO_NOEXCEPT
function ASIO_MUTABLE_BUFFER (line 1003) | inline ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
function ASIO_CONST_BUFFER (line 1019) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1033) | inline ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
type detail (line 1055) | namespace detail {
type one_buffer (line 534) | struct one_buffer {}
type multiple_buffers (line 535) | struct multiple_buffers {}
type buffer_sequence_cardinality (line 539) | struct buffer_sequence_cardinality :
function buffer_size (line 550) | inline std::size_t buffer_size(one_buffer,
function buffer_size (line 557) | inline std::size_t buffer_size(multiple_buffers,
class buffer_debug_check (line 702) | class buffer_debug_check
method buffer_debug_check (line 705) | buffer_debug_check(Iterator iter)
type buffer_types_base (line 1058) | struct buffer_types_base
type buffer_types_base<false> (line 1061) | struct buffer_types_base<false>
type buffer_types_base<true> (line 1068) | struct buffer_types_base<true>
type buffer_types (line 1075) | struct buffer_types
function buffer (line 1083) | inline typename detail::buffer_types<PodType>::container_type
function buffer (line 1095) | inline typename detail::buffer_types<PodType>::container_type
function ASIO_MUTABLE_BUFFER (line 1119) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 1134) | inline ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
function ASIO_CONST_BUFFER (line 1150) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1164) | inline ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
function ASIO_CONST_BUFFER (line 1182) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1196) | inline ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
function ASIO_MUTABLE_BUFFER (line 1214) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 1228) | inline ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
function ASIO_CONST_BUFFER (line 1244) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1258) | inline ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
function ASIO_CONST_BUFFER (line 1274) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1288) | inline ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
function ASIO_MUTABLE_BUFFER (line 1309) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 1333) | inline ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
function ASIO_CONST_BUFFER (line 1358) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1382) | inline ASIO_CONST_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 1406) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_MUTABLE_BUFFER (line 1430) | inline ASIO_MUTABLE_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1453) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1476) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1500) | inline ASIO_CONST_BUFFER buffer(
function ASIO_CONST_BUFFER (line 1521) | inline ASIO_CONST_BUFFER buffer(
function dynamic_string_buffer (line 1569) | explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator...
function max_size (line 1622) | std::size_t max_size() const ASIO_NOEXCEPT
function capacity (line 1633) | std::size_t capacity() const ASIO_NOEXCEPT
function const_buffers_type (line 1649) | const_buffers_type data() const ASIO_NOEXCEPT
function mutable_buffers_type (line 1670) | mutable_buffers_type data(std::size_t pos, std::size_t n) ASIO_NOEXCEPT
function const_buffers_type (line 1688) | const_buffers_type data(std::size_t pos,
function mutable_buffers_type (line 1712) | mutable_buffers_type prepare(std::size_t n)
function commit (line 1741) | void commit(std::size_t n)
function grow (line 1755) | void grow(std::size_t n)
function shrink (line 1773) | void shrink(std::size_t n)
function consume (line 1790) | void consume(std::size_t n)
function dynamic_vector_buffer (line 1837) | explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
function max_size (line 1892) | std::size_t max_size() const ASIO_NOEXCEPT
function capacity (line 1905) | std::size_t capacity() const ASIO_NOEXCEPT
function const_buffers_type (line 1922) | const_buffers_type data() const ASIO_NOEXCEPT
function mutable_buffers_type (line 1943) | mutable_buffers_type data(std::size_t pos, std::size_t n) ASIO_NOEXCEPT
function const_buffers_type (line 1961) | const_buffers_type data(std::size_t pos,
function mutable_buffers_type (line 1985) | mutable_buffers_type prepare(std::size_t n)
function commit (line 2014) | void commit(std::size_t n)
function grow (line 2028) | void grow(std::size_t n)
function shrink (line 2046) | void shrink(std::size_t n)
function consume (line 2063) | void consume(std::size_t n)
function dynamic_buffer (line 2097) | inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
function dynamic_buffer (line 2109) | inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
function dynamic_buffer (line 2121) | inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
function dynamic_buffer (line 2132) | inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
function namespace (line 2169) | namespace detail {
function buffer_copy (line 2361) | inline std::size_t buffer_copy(const MutableBufferSequence& target,
function buffer_copy (line 2398) | inline std::size_t buffer_copy(const MutableBufferSequence& target,
function asio (line 2415) | asio/detail/pop_options.hpp"
class mutable_buffer (line 68) | class mutable_buffer
method mutable_buffer (line 94) | mutable_buffer() ASIO_NOEXCEPT
method mutable_buffer (line 101) | mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffer (line 108) | mutable_buffer(void* data, std::size_t size,
method mutable_buffer (line 139) | mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
class const_buffer (line 69) | class const_buffer
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
class mutable_buffer (line 90) | class mutable_buffer
method mutable_buffer (line 94) | mutable_buffer() ASIO_NOEXCEPT
method mutable_buffer (line 101) | mutable_buffer(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffer (line 108) | mutable_buffer(void* data, std::size_t size,
method mutable_buffer (line 139) | mutable_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
class mutable_buffers_1 (line 160) | class mutable_buffers_1
method mutable_buffers_1 (line 171) | mutable_buffers_1(void* data, std::size_t size) ASIO_NOEXCEPT
method mutable_buffers_1 (line 177) | mutable_buffers_1(void* data, std::size_t size,
method mutable_buffers_1 (line 185) | explicit mutable_buffers_1(const mutable_buffer& b) ASIO_NOEXCEPT
method const_iterator (line 191) | const_iterator begin() const ASIO_NOEXCEPT
method const_iterator (line 197) | const_iterator end() const ASIO_NOEXCEPT
class const_buffer (line 224) | class const_buffer
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
function const_buffer (line 252) | const_buffer(const void* data, std::size_t size,
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
function ASIO_NOEXCEPT (line 277) | std::size_t size() const ASIO_NOEXCEPT
function const_buffer (line 283) | const_buffer& operator+=(std::size_t n) ASIO_NOEXCEPT
method const_buffer (line 228) | const_buffer() ASIO_NOEXCEPT
method const_buffer (line 235) | const_buffer(const void* data, std::size_t size) ASIO_NOEXCEPT
FILE: src/third_party/asio/buffered_read_stream.hpp
type asio (line 32) | namespace asio {
class buffered_read_stream (line 47) | class buffered_read_stream
method buffered_read_stream (line 69) | explicit buffered_read_stream(Arg& a)
method buffered_read_stream (line 77) | buffered_read_stream(Arg& a, std::size_t buffer_size)
method next_layer_type (line 84) | next_layer_type& next_layer()
method lowest_layer_type (line 90) | lowest_layer_type& lowest_layer()
method lowest_layer_type (line 96) | const lowest_layer_type& lowest_layer() const
method executor_type (line 102) | executor_type get_executor() ASIO_NOEXCEPT
method close (line 108) | void close()
method ASIO_SYNC_OP_VOID (line 114) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
method write_some (line 123) | std::size_t write_some(const ConstBufferSequence& buffers)
method write_some (line 131) | std::size_t write_some(const ConstBufferSequence& buffers,
method WriteHandler (line 141) | WriteHandler
method in_avail (line 207) | std::size_t in_avail()
method in_avail (line 213) | std::size_t in_avail(asio::error_code& ec)
method copy (line 223) | std::size_t copy(const MutableBufferSequence& buffers)
method peek_copy (line 235) | std::size_t peek_copy(const MutableBufferSequence& buffers)
FILE: src/third_party/asio/buffered_read_stream_fwd.hpp
type asio (line 18) | namespace asio {
class buffered_read_stream (line 21) | class buffered_read_stream
FILE: src/third_party/asio/buffered_stream.hpp
type asio (line 29) | namespace asio {
class buffered_stream (line 44) | class buffered_stream
method buffered_stream (line 59) | explicit buffered_stream(Arg& a)
method buffered_stream (line 67) | explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
method next_layer_type (line 75) | next_layer_type& next_layer()
method lowest_layer_type (line 81) | lowest_layer_type& lowest_layer()
method lowest_layer_type (line 87) | const lowest_layer_type& lowest_layer() const
method executor_type (line 93) | executor_type get_executor() ASIO_NOEXCEPT
method close (line 99) | void close()
method ASIO_SYNC_OP_VOID (line 105) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
method flush (line 114) | std::size_t flush()
method flush (line 122) | std::size_t flush(asio::error_code& ec)
method WriteHandler (line 130) | WriteHandler
method write_some (line 145) | std::size_t write_some(const ConstBufferSequence& buffers)
method write_some (line 153) | std::size_t write_some(const ConstBufferSequence& buffers,
method WriteHandler (line 163) | WriteHandler
method fill (line 177) | std::size_t fill()
method fill (line 184) | std::size_t fill(asio::error_code& ec)
method ReadHandler (line 192) | ReadHandler
method read_some (line 206) | std::size_t read_some(const MutableBufferSequence& buffers)
method read_some (line 214) | std::size_t read_some(const MutableBufferSequence& buffers,
method ReadHandler (line 224) | ReadHandler
method peek (line 239) | std::size_t peek(const MutableBufferSequence& buffers)
method peek (line 247) | std::size_t peek(const MutableBufferSequence& buffers,
method in_avail (line 254) | std::size_t in_avail()
method in_avail (line 260) | std::size_t in_avail(asio::error_code& ec)
FILE: src/third_party/asio/buffered_stream_fwd.hpp
type asio (line 18) | namespace asio {
class buffered_stream (line 21) | class buffered_stream
FILE: src/third_party/asio/buffered_write_stream.hpp
type asio (line 32) | namespace asio {
class buffered_write_stream (line 47) | class buffered_write_stream
method buffered_write_stream (line 69) | explicit buffered_write_stream(Arg& a)
method buffered_write_stream (line 77) | buffered_write_stream(Arg& a, std::size_t buffer_size)
method next_layer_type (line 84) | next_layer_type& next_layer()
method lowest_layer_type (line 90) | lowest_layer_type& lowest_layer()
method lowest_layer_type (line 96) | const lowest_layer_type& lowest_layer() const
method executor_type (line 102) | executor_type get_executor() ASIO_NOEXCEPT
method close (line 108) | void close()
method ASIO_SYNC_OP_VOID (line 114) | ASIO_SYNC_OP_VOID close(asio::error_code& ec)
method read_some (line 167) | std::size_t read_some(const MutableBufferSequence& buffers)
method read_some (line 175) | std::size_t read_some(const MutableBufferSequence& buffers,
method ReadHandler (line 185) | ReadHandler
method peek (line 200) | std::size_t peek(const MutableBufferSequence& buffers)
method peek (line 208) | std::size_t peek(const MutableBufferSequence& buffers,
method in_avail (line 215) | std::size_t in_avail()
method in_avail (line 221) | std::size_t in_avail(asio::error_code& ec)
FILE: src/third_party/asio/buffered_write_stream_fwd.hpp
type asio (line 18) | namespace asio {
class buffered_write_stream (line 21) | class buffered_write_stream
FILE: src/third_party/asio/buffers_iterator.hpp
type asio (line 27) | namespace asio {
type detail (line 29) | namespace detail
type buffers_iterator_types_helper (line 32) | struct buffers_iterator_types_helper
type buffers_iterator_types_helper<false> (line 35) | struct buffers_iterator_types_helper<false>
type byte_type (line 39) | struct byte_type
type buffers_iterator_types_helper<true> (line 46) | struct buffers_iterator_types_helper<true>
type byte_type (line 50) | struct byte_type
type buffers_iterator_types (line 57) | struct buffers_iterator_types
type buffers_iterator_types<mutable_buffer, ByteType> (line 72) | struct buffers_iterator_types<mutable_buffer, ByteType>
type buffers_iterator_types<const_buffer, ByteType> (line 80) | struct buffers_iterator_types<const_buffer, ByteType>
type buffers_iterator_types<mutable_buffers_1, ByteType> (line 90) | struct buffers_iterator_types<mutable_buffers_1, ByteType>
type buffers_iterator_types<const_buffers_1, ByteType> (line 98) | struct buffers_iterator_types<const_buffers_1, ByteType>
class buffers_iterator (line 110) | class buffers_iterator
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function reference (line 206) | reference operator*() const
function pointer (line 212) | pointer operator->() const
function reference (line 218) | reference operator[](std::ptrdiff_t difference) const
function buffers_iterator (line 226) | buffers_iterator& operator++()
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function buffers_iterator (line 233) | buffers_iterator operator++(int)
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function buffers_iterator (line 241) | buffers_iterator& operator--()
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function buffers_iterator (line 248) | buffers_iterator operator--(int)
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function buffers_iterator (line 256) | buffers_iterator& operator+=(std::ptrdiff_t difference)
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function buffers_iterator (line 263) | buffers_iterator& operator-=(std::ptrdiff_t difference)
method buffers_iterator (line 156) | buffers_iterator()
method while (line 176) | while (new_iter.current_ != new_iter.end_)
function friend (line 270) | friend buffers_iterator operator+(const buffers_iterator& iter,
function friend (line 279) | friend buffers_iterator operator+(std::ptrdiff_t difference,
function friend (line 288) | friend buffers_iterator operator-(const buffers_iterator& iter,
function friend (line 297) | friend std::ptrdiff_t operator-(const buffers_iterator& a,
function friend (line 304) | friend bool operator==(const buffers_iterator& a, const buffers_iterat...
function friend (line 310) | friend bool operator!=(const buffers_iterator& a, const buffers_iterat...
function friend (line 316) | friend bool operator<(const buffers_iterator& a, const buffers_iterato...
function friend (line 322) | friend bool operator<=(const buffers_iterator& a, const buffers_iterat...
function friend (line 328) | friend bool operator>(const buffers_iterator& a, const buffers_iterato...
function friend (line 334) | friend bool operator>=(const buffers_iterator& a, const buffers_iterat...
function equal (line 348) | bool equal(const buffers_iterator& other) const
function increment (line 354) | void increment()
function decrement (line 377) | void decrement()
function advance (line 407) | void advance(std::ptrdiff_t n)
function distance_to (line 488) | std::ptrdiff_t distance_to(const buffers_iterator& other) const
function buffers_begin (line 503) | inline buffers_iterator<BufferSequence> buffers_begin(
function buffers_end (line 511) | inline buffers_iterator<BufferSequence> buffers_end(
FILE: src/third_party/asio/co_spawn.hpp
type asio (line 28) | namespace asio {
type detail (line 29) | namespace detail {
type awaitable_signature (line 32) | struct awaitable_signature
type awaitable_signature<awaitable<T, Executor>> (line 35) | struct awaitable_signature<awaitable<T, Executor>>
type awaitable_signature<awaitable<void, Executor>> (line 41) | struct awaitable_signature<awaitable<void, Executor>>
FILE: src/third_party/asio/completion_condition.hpp
type asio (line 23) | namespace asio {
type detail (line 25) | namespace detail {
type default_max_transfer_size_t (line 28) | enum default_max_transfer_size_t { default_max_transfer_size = 65536 }
function adapt_completion_condition_result (line 32) | inline std::size_t adapt_completion_condition_result(bool result)
function adapt_completion_condition_result (line 40) | inline std::size_t adapt_completion_condition_result(std::size_t res...
class transfer_all_t (line 45) | class transfer_all_t
class transfer_at_least_t (line 57) | class transfer_at_least_t
method transfer_at_least_t (line 62) | explicit transfer_at_least_t(std::size_t minimum)
class transfer_exactly_t (line 78) | class transfer_exactly_t
method transfer_exactly_t (line 83) | explicit transfer_exactly_t(std::size_t size)
function transfer_all (line 138) | inline detail::transfer_all_t transfer_all()
function transfer_at_least (line 172) | inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
function transfer_exactly (line 206) | inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
FILE: src/third_party/asio/compose.hpp
type asio (line 23) | namespace asio {
FILE: src/third_party/asio/connect.hpp
type asio (line 26) | namespace asio {
type detail (line 28) | namespace detail
type has_iterator_typedef (line 36) | struct has_iterator_typedef
type is_endpoint_sequence (line 45) | struct is_endpoint_sequence
FILE: src/third_party/asio/coroutine.hpp
type asio (line 14) | namespace asio {
type detail (line 15) | namespace detail {
class coroutine_ref (line 17) | class coroutine_ref
method coroutine_ref (line 267) | coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
method coroutine_ref (line 268) | coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
class coroutine_ref (line 264) | class coroutine_ref
method coroutine_ref (line 267) | coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
method coroutine_ref (line 268) | coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
class coroutine (line 241) | class coroutine
method coroutine (line 245) | coroutine() : value_(0) {}
method is_child (line 248) | bool is_child() const { return value_ < 0; }
method is_parent (line 251) | bool is_parent() const { return !is_child(); }
method is_complete (line 254) | bool is_complete() const { return value_ == -1; }
type detail (line 262) | namespace detail {
class coroutine_ref (line 17) | class coroutine_ref
method coroutine_ref (line 267) | coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
method coroutine_ref (line 268) | coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
class coroutine_ref (line 264) | class coroutine_ref
method coroutine_ref (line 267) | coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
method coroutine_ref (line 268) | coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
FILE: src/third_party/asio/deadline_timer.hpp
type asio (line 28) | namespace asio {
FILE: src/third_party/asio/defer.hpp
type asio (line 26) | namespace asio {
FILE: src/third_party/asio/detached.hpp
type asio (line 23) | namespace asio {
class detached_t (line 37) | class detached_t
method ASIO_CONSTEXPR (line 41) | ASIO_CONSTEXPR detached_t()
FILE: src/third_party/asio/detail/array.hpp
type asio (line 26) | namespace asio {
type detail (line 27) | namespace detail {
FILE: src/third_party/asio/detail/array_fwd.hpp
type boost (line 20) | namespace boost {
class array (line 23) | class array
FILE: src/third_party/asio/detail/atomic_count.hpp
type asio (line 28) | namespace asio {
type detail (line 29) | namespace detail {
function increment (line 33) | inline void increment(atomic_count& a, long b) { a += b; }
function increment (line 36) | inline void increment(atomic_count& a, long b) { a += b; }
function increment (line 39) | inline void increment(atomic_count& a, long b) { while (b > 0) ++a, ...
FILE: src/third_party/asio/detail/base_from_completion_cond.hpp
type asio (line 23) | namespace asio {
type detail (line 24) | namespace detail {
class base_from_completion_cond (line 27) | class base_from_completion_cond
method base_from_completion_cond (line 30) | explicit base_from_completion_cond(CompletionCondition& completion...
method check_for_completion (line 36) | std::size_t check_for_completion(
class base_from_completion_cond<transfer_all_t> (line 49) | class base_from_completion_cond<transfer_all_t>
method base_from_completion_cond (line 52) | explicit base_from_completion_cond(transfer_all_t)
method check_for_completion (line 56) | static std::size_t check_for_completion(
FILE: src/third_party/asio/detail/bind_handler.hpp
type asio (line 28) | namespace asio {
type detail (line 29) | namespace detail {
class binder1 (line 32) | class binder1
method binder1 (line 36) | binder1(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1)
method binder1 (line 42) | binder1(Handler& handler, const Arg1& arg1)
method binder1 (line 49) | binder1(const binder1& other)
method binder1 (line 55) | binder1(binder1&& other)
function asio_handler_deallocate (line 86) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 94) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 102) | inline void asio_handler_invoke(Function& function,
function asio_handler_invoke (line 110) | inline void asio_handler_invoke(const Function& function,
function bind_handler (line 118) | inline binder1<typename decay<Handler>::type, Arg1> bind_handler(
class binder2 (line 126) | class binder2
method binder2 (line 130) | binder2(int, ASIO_MOVE_ARG(T) handler,
method binder2 (line 138) | binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
method binder2 (line 146) | binder2(const binder2& other)
method binder2 (line 153) | binder2(binder2&& other)
function asio_handler_deallocate (line 187) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 195) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 203) | inline void asio_handler_invoke(Function& function,
function asio_handler_invoke (line 211) | inline void asio_handler_invoke(const Function& function,
function bind_handler (line 219) | inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler(
class binder3 (line 227) | class binder3
method binder3 (line 231) | binder3(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
method binder3 (line 240) | binder3(Handler& handler, const Arg1& arg1,
method binder3 (line 250) | binder3(const binder3& other)
method binder3 (line 258) | binder3(binder3&& other)
function asio_handler_deallocate (line 294) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 302) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 311) | inline void asio_handler_invoke(Function& function,
function asio_handler_invoke (line 320) | inline void asio_handler_invoke(const Function& function,
function bind_handler (line 328) | inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind...
class binder4 (line 338) | class binder4
method binder4 (line 342) | binder4(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
method binder4 (line 352) | binder4(Handler& handler, const Arg1& arg1,
method binder4 (line 363) | binder4(const binder4& other)
method binder4 (line 372) | binder4(binder4&& other)
function asio_handler_deallocate (line 413) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 422) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 431) | inline void asio_handler_invoke(Function& function,
function asio_handler_invoke (line 440) | inline void asio_handler_invoke(const Function& function,
function bind_handler (line 449) | inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>
class binder5 (line 459) | class binder5
method binder5 (line 463) | binder5(int, ASIO_MOVE_ARG(T) handler, const Arg1& arg1,
method binder5 (line 474) | binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
method binder5 (line 486) | binder5(const binder5& other)
method binder5 (line 496) | binder5(binder5&& other)
function asio_handler_deallocate (line 539) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 548) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 557) | inline void asio_handler_invoke(Function& function,
function asio_handler_invoke (line 566) | inline void asio_handler_invoke(const Function& function,
function bind_handler (line 575) | inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4...
class move_binder1 (line 586) | class move_binder1
method move_binder1 (line 589) | move_binder1(int, ASIO_MOVE_ARG(Handler) handler,
method move_binder1 (line 596) | move_binder1(move_binder1&& other)
function asio_handler_deallocate (line 621) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 629) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 637) | inline void asio_handler_invoke(ASIO_MOVE_ARG(Function) function,
class move_binder2 (line 645) | class move_binder2
method move_binder2 (line 648) | move_binder2(int, ASIO_MOVE_ARG(Handler) handler,
method move_binder2 (line 656) | move_binder2(move_binder2&& other)
function asio_handler_deallocate (line 684) | inline void asio_handler_deallocate(void* pointer, std::size_t size,
function asio_handler_is_continuation (line 692) | inline bool asio_handler_is_continuation(
function asio_handler_invoke (line 700) | inline void asio_handler_invoke(ASIO_MOVE_ARG(Function) function,
type associated_allocator<detail::binder1<Handler, Arg1>, Allocator> (line 712) | struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
method type (line 716) | static type get(const detail::binder1<Handler, Arg1>& h,
type associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator> (line 724) | struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allo...
method type (line 728) | static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
type associated_executor<detail::binder1<Handler, Arg1>, Executor> (line 736) | struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
method type (line 740) | static type get(const detail::binder1<Handler, Arg1>& h,
type associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor> (line 748) | struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Execu...
method type (line 752) | static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
type associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator> (line 762) | struct associated_allocator<detail::move_binder1<Handler, Arg1>, Alloc...
method type (line 766) | static type get(const detail::move_binder1<Handler, Arg1>& h,
type associated_allocator<
detail::move_binder2<Handler, Arg1, Arg2>, Allocator> (line 774) | struct associated_allocator<
method type (line 779) | static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
type associated_executor<detail::move_binder1<Handler, Arg1>, Executor> (line 787) | struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
method type (line 791) | static type get(const detail::move_binder1<Handler, Arg1>& h,
type associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor> (line 799) | struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, ...
method type (line 803) | static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
FILE: src/third_party/asio/detail/buffer_resize_guard.hpp
type asio (line 23) | namespace asio {
type detail (line 24) | namespace detail {
class buffer_resize_guard (line 28) | class buffer_resize_guard
method buffer_resize_guard (line 32) | buffer_resize_guard(Buffer& buffer)
method commit (line 48) | void commit()
FILE: src/third_party/asio/detail/buffer_sequence_adapter.hpp
type asio (line 25) | namespace asio {
type detail (line 26) | namespace detail {
class buffer_sequence_adapter_base (line 28) | class buffer_sequence_adapter_base
method init_native_buffer (line 53) | static void init_native_buffer(WSABUF& buf,
method init_native_buffer (line 60) | static void init_native_buffer(WSABUF& buf,
method init_iov_base (line 74) | static void init_iov_base(void*& base, void* addr)
method init_iov_base (line 80) | static void init_iov_base(T& base, void* addr)
method init_native_buffer (line 85) | static void init_native_buffer(iovec& iov,
method init_native_buffer (line 92) | static void init_native_buffer(iovec& iov,
class buffer_sequence_adapter (line 103) | class buffer_sequence_adapter
method buffer_sequence_adapter (line 107) | explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
method native_buffer_type (line 115) | native_buffer_type* buffers()
method count (line 120) | std::size_t count() const
method total_size (line 125) | std::size_t total_size() const
method all_empty (line 130) | bool all_empty() const
method all_empty (line 135) | static bool all_empty(const Buffers& buffer_sequence)
method validate (line 142) | static void validate(const Buffers& buffer_sequence)
method Buffer (line 149) | static Buffer first(const Buffers& buffer_sequence)
method init (line 158) | void init(Iterator begin, Iterator end)
method all_empty (line 170) | static bool all_empty(Iterator begin, Iterator end)
method validate (line 181) | static void validate(Iterator begin, Iterator end)
method Buffer (line 192) | static Buffer first(Iterator begin, Iterator end)
class buffer_sequence_adapter<Buffer, asio::mutable_buffer> (line 210) | class buffer_sequence_adapter<Buffer, asio::mutable_buffer>
method buffer_sequence_adapter (line 214) | explicit buffer_sequence_adapter(
method native_buffer_type (line 221) | native_buffer_type* buffers()
method count (line 226) | std::size_t count() const
method total_size (line 231) | std::size_t total_size() const
method all_empty (line 236) | bool all_empty() const
method all_empty (line 241) | static bool all_empty(const asio::mutable_buffer& buffer_sequence)
method validate (line 246) | static void validate(const asio::mutable_buffer& buffer_sequence)
method Buffer (line 251) | static Buffer first(const asio::mutable_buffer& buffer_sequence)
class buffer_sequence_adapter<Buffer, asio::const_buffer> (line 262) | class buffer_sequence_adapter<Buffer, asio::const_buffer>
method buffer_sequence_adapter (line 266) | explicit buffer_sequence_adapter(
method native_buffer_type (line 273) | native_buffer_type* buffers()
method count (line 278) | std::size_t count() const
method total_size (line 283) | std::size_t total_size() const
method all_empty (line 288) | bool all_empty() const
method all_empty (line 293) | static bool all_empty(const asio::const_buffer& buffer_sequence)
method validate (line 298) | static void validate(const asio::const_buffer& buffer_sequence)
method Buffer (line 303) | static Buffer first(const asio::const_buffer& buffer_sequence)
class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1> (line 316) | class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
method buffer_sequence_adapter (line 320) | explicit buffer_sequence_adapter(
method native_buffer_type (line 327) | native_buffer_type* buffers()
method count (line 332) | std::size_t count() const
method total_size (line 337) | std::size_t total_size() const
method all_empty (line 342) | bool all_empty() const
method all_empty (line 347) | static bool all_empty(const asio::mutable_buffers_1& buffer_sequence)
method validate (line 352) | static void validate(const asio::mutable_buffers_1& buffer_sequence)
method Buffer (line 357) | static Buffer first(const asio::mutable_buffers_1& buffer_sequence)
class buffer_sequence_adapter<Buffer, asio::const_buffers_1> (line 368) | class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
method buffer_sequence_adapter (line 372) | explicit buffer_sequence_adapter(
method native_buffer_type (line 379) | native_buffer_type* buffers()
method count (line 384) | std::size_t count() const
method total_size (line 389) | std::size_t total_size() const
method all_empty (line 394) | bool all_empty() const
method all_empty (line 399) | static bool all_empty(const asio::const_buffers_1& buffer_sequence)
method validate (line 404) | static void validate(const asio::const_buffers_1& buffer_sequence)
method Buffer (line 409) | static Buffer first(const asio::const_buffers_1& buffer_sequence)
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> > (line 422) | class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
method buffer_sequence_adapter (line 426) | explicit buffer_sequence_adapter(
method native_buffer_type (line 434) | native_buffer_type* buffers()
method count (line 439) | std::size_t count() const
method total_size (line 444) | std::size_t total_size() const
method all_empty (line 449) | bool all_empty() const
method all_empty (line 454) | static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
method validate (line 459) | static void validate(const boost::array<Elem, 2>& buffer_sequence)
method Buffer (line 465) | static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> > (line 479) | class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
method buffer_sequence_adapter (line 483) | explicit buffer_sequence_adapter(
method native_buffer_type (line 491) | native_buffer_type* buffers()
method count (line 496) | std::size_t count() const
method total_size (line 501) | std::size_t total_size() const
method all_empty (line 506) | bool all_empty() const
method all_empty (line 511) | static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
method validate (line 516) | static void validate(const std::array<Elem, 2>& buffer_sequence)
method Buffer (line 522) | static Buffer first(const std::array<Elem, 2>& buffer_sequence)
FILE: src/third_party/asio/detail/buffered_stream_storage.hpp
type asio (line 27) | namespace asio {
type detail (line 28) | namespace detail {
class buffered_stream_storage (line 30) | class buffered_stream_storage
method buffered_stream_storage (line 40) | explicit buffered_stream_storage(std::size_t buffer_capacity)
method clear (line 48) | void clear()
method mutable_buffer (line 55) | mutable_buffer data()
method const_buffer (line 61) | const_buffer data() const
method empty (line 67) | bool empty() const
method size_type (line 73) | size_type size() const
method resize (line 79) | void resize(size_type length)
method size_type (line 96) | size_type capacity() const
method consume (line 102) | void consume(size_type count)
FILE: src/third_party/asio/detail/call_stack.hpp
type asio (line 24) | namespace asio {
type detail (line 25) | namespace detail {
class call_stack (line 30) | class call_stack
class context (line 34) | class context
method context (line 39) | explicit context(Key* k)
method context (line 48) | context(Key* k, Value& v)
method Value (line 63) | Value* next_by_key() const
method Value (line 92) | static Value* contains(Key* k)
method Value (line 105) | static Value* top()
FILE: src/third_party/asio/detail/chrono.hpp
type asio (line 26) | namespace asio {
type chrono (line 27) | namespace chrono {
FILE: src/third_party/asio/detail/chrono_time_traits.hpp
type asio (line 22) | namespace asio {
type detail (line 23) | namespace detail {
type gcd (line 27) | struct gcd { enum { value = gcd<v2, v1 % v2>::value }; }
type gcd<v1, 0> (line 30) | struct gcd<v1, 0> { enum { value = v1 }; }
type chrono_time_traits (line 34) | struct chrono_time_traits
method time_type (line 49) | static time_type now()
method time_type (line 55) | static time_type add(const time_type& t, const duration_type& d)
method duration_type (line 73) | static duration_type subtract(const time_type& t1, const time_type...
method less_than (line 117) | static bool less_than(const time_type& t1, const time_type& t2)
class posix_time_duration (line 124) | class posix_time_duration
method posix_time_duration (line 127) | explicit posix_time_duration(const duration_type& d)
method ticks (line 132) | int64_t ticks() const
method total_seconds (line 137) | int64_t total_seconds() const
method total_milliseconds (line 142) | int64_t total_milliseconds() const
method total_microseconds (line 147) | int64_t total_microseconds() const
method duration_cast (line 154) | int64_t duration_cast() const
method posix_time_duration (line 179) | static posix_time_duration to_posix_duration(const duration_type& d)
method posix_time_duration (line 127) | explicit posix_time_duration(const duration_type& d)
method ticks (line 132) | int64_t ticks() const
method total_seconds (line 137) | int64_t total_seconds() const
method total_milliseconds (line 142) | int64_t total_milliseconds() const
method total_microseconds (line 147) | int64_t total_microseconds() const
method duration_cast (line 154) | int64_t duration_cast() const
FILE: src/third_party/asio/detail/completion_handler.hpp
type asio (line 27) | namespace asio {
type detail (line 28) | namespace detail {
class completion_handler (line 31) | class completion_handler : public operation
method completion_handler (line 36) | completion_handler(Handler& h)
method do_complete (line 43) | static void do_complete(void* owner, operation* base,
FILE: src/third_party/asio/detail/conditionally_enabled_event.hpp
type asio (line 27) | namespace asio {
type detail (line 28) | namespace detail {
class conditionally_enabled_event (line 31) | class conditionally_enabled_event
method conditionally_enabled_event (line 36) | conditionally_enabled_event()
method signal (line 46) | void signal(conditionally_enabled_mutex::scoped_lock& lock)
method signal_all (line 53) | void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
method unlock_and_signal_one (line 60) | void unlock_and_signal_one(
method maybe_unlock_and_signal_one (line 68) | bool maybe_unlock_and_signal_one(
method clear (line 78) | void clear(conditionally_enabled_mutex::scoped_lock& lock)
method wait (line 85) | void wait(conditionally_enabled_mutex::scoped_lock& lock)
method wait_for_usec (line 94) | bool wait_for_usec(
FILE: src/third_party/asio/detail/conditionally_enabled_mutex.hpp
type asio (line 25) | namespace asio {
type detail (line 26) | namespace detail {
class conditionally_enabled_mutex (line 29) | class conditionally_enabled_mutex
class scoped_lock (line 34) | class scoped_lock
type adopt_lock_t (line 39) | enum adopt_lock_t { adopt_lock }
method scoped_lock (line 42) | scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
method scoped_lock (line 49) | explicit scoped_lock(conditionally_enabled_mutex& m)
method lock (line 69) | void lock()
method unlock (line 79) | void unlock()
method locked (line 89) | bool locked() const
method conditionally_enabled_mutex (line 107) | explicit conditionally_enabled_mutex(bool enabled)
method enabled (line 118) | bool enabled() const
method lock (line 124) | void lock()
method unlock (line 131) | void unlock()
FILE: src/third_party/asio/detail/consuming_buffers.hpp
type asio (line 26) | namespace asio {
type detail (line 27) | namespace detail {
type prepared_buffers_max (line 31) | struct prepared_buffers_max
type prepared_buffers_max<boost::array<Elem, N> > (line 37) | struct prepared_buffers_max<boost::array<Elem, N> >
type prepared_buffers_max<std::array<Elem, N> > (line 45) | struct prepared_buffers_max<std::array<Elem, N> >
type prepared_buffers (line 54) | struct prepared_buffers
method prepared_buffers (line 61) | prepared_buffers() : count(0) {}
method const_iterator (line 62) | const_iterator begin() const { return elems; }
method const_iterator (line 63) | const_iterator end() const { return elems + count; }
class consuming_buffers (line 71) | class consuming_buffers
method consuming_buffers (line 78) | explicit consuming_buffers(const Buffers& buffers)
method empty (line 89) | bool empty() const
method prepared_buffers_type (line 95) | prepared_buffers_type prepare(std::size_t max_size)
method consume (line 119) | void consume(std::size_t size)
method total_consumed (line 146) | std::size_t total_consumed() const
class consuming_single_buffer (line 161) | class consuming_single_buffer
method consuming_single_buffer (line 166) | explicit consuming_single_buffer(const Buffer1& buffer)
method empty (line 173) | bool empty() const
method Buffer (line 179) | Buffer prepare(std::size_t max_size)
method consume (line 185) | void consume(std::size_t size)
method total_consumed (line 191) | std::size_t total_consumed() const
class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*> (line 202) | class consuming_buffers<mutable_buffer, mutable_buffer, const mutabl...
method consuming_buffers (line 206) | explicit consuming_buffers(const mutable_buffer& buffer)
class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*> (line 213) | class consuming_buffers<const_buffer, mutable_buffer, const mutable_...
method consuming_buffers (line 217) | explicit consuming_buffers(const mutable_buffer& buffer)
class consuming_buffers<const_buffer, const_buffer, const const_buffer*> (line 224) | class consuming_buffers<const_buffer, const_buffer, const const_buff...
method consuming_buffers (line 228) | explicit consuming_buffers(const const_buffer& buffer)
class consuming_buffers<mutable_buffer,
mutable_buffers_1, const mutable_buffer*> (line 237) | class consuming_buffers<mutable_buffer,
method consuming_buffers (line 242) | explicit consuming_buffers(const mutable_buffers_1& buffer)
class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*> (line 249) | class consuming_buffers<const_buffer, mutable_buffers_1, const mutab...
method consuming_buffers (line 253) | explicit consuming_buffers(const mutable_buffers_1& buffer)
class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*> (line 260) | class consuming_buffers<const_buffer, const_buffers_1, const const_b...
method consuming_buffers (line 264) | explicit consuming_buffers(const const_buffers_1& buffer)
class consuming_buffers<Buffer, boost::array<Elem, 2>,
typename boost::array<Elem, 2>::const_iterator> (line 273) | class consuming_buffers<Buffer, boost::array<Elem, 2>,
method consuming_buffers (line 278) | explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
method empty (line 285) | bool empty() const
method prepare (line 292) | boost::array<Buffer, 2> prepare(std::size_t max_size)
method consume (line 306) | void consume(std::size_t size)
method total_consumed (line 312) | std::size_t total_consumed() const
class consuming_buffers<Buffer, std::array<Elem, 2>,
typename std::array<Elem, 2>::const_iterator> (line 325) | class consuming_buffers<Buffer, std::array<Elem, 2>,
method consuming_buffers (line 330) | explicit consuming_buffers(const std::array<Elem, 2>& buffers)
method empty (line 337) | bool empty() const
method prepare (line 344) | std::array<Buffer, 2> prepare(std::size_t max_size)
method consume (line 358) | void consume(std::size_t size)
method total_consumed (line 364) | std::size_t total_consumed() const
class consuming_buffers<Buffer, null_buffers, const mutable_buffer*> (line 379) | class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
method consuming_buffers (line 383) | consuming_buffers(const null_buffers&)
method empty (line 388) | bool empty()
method null_buffers (line 393) | null_buffers prepare(std::size_t)
method consume (line 398) | void consume(std::size_t)
method total_consumed (line 403) | std::size_t total_consumed() const
FILE: src/third_party/asio/detail/cstddef.hpp
type asio (line 21) | namespace asio {
type nullptr_t (line 26) | struct nullptr_t {}
FILE: src/third_party/asio/detail/cstdint.hpp
type asio (line 26) | namespace asio {
FILE: src/third_party/asio/detail/date_time_fwd.hpp
type boost (line 20) | namespace boost {
type date_time (line 21) | namespace date_time {
class base_time (line 24) | class base_time
type posix_time (line 27) | namespace posix_time {
class ptime (line 29) | class ptime
FILE: src/third_party/asio/detail/deadline_timer_service.hpp
type asio (line 41) | namespace asio {
type detail (line 42) | namespace detail {
class deadline_timer_service (line 45) | class deadline_timer_service
type implementation_type (line 57) | struct implementation_type
method deadline_timer_service (line 66) | deadline_timer_service(execution_context& context)
method shutdown (line 82) | void shutdown()
method construct (line 87) | void construct(implementation_type& impl)
method destroy (line 94) | void destroy(implementation_type& impl)
method move_construct (line 101) | void move_construct(implementation_type& impl,
method move_assign (line 114) | void move_assign(implementation_type& impl,
method cancel (line 133) | std::size_t cancel(implementation_type& impl, asio::error_code& ec)
method cancel_one (line 151) | std::size_t cancel_one(implementation_type& impl,
method time_type (line 172) | time_type expiry(const implementation_type& impl) const
method time_type (line 178) | time_type expires_at(const implementation_type& impl) const
method duration_type (line 184) | duration_type expires_from_now(const implementation_type& impl) const
method expires_at (line 190) | std::size_t expires_at(implementation_type& impl,
method expires_after (line 200) | std::size_t expires_after(implementation_type& impl,
method expires_from_now (line 208) | std::size_t expires_from_now(implementation_type& impl,
method wait (line 216) | void wait(implementation_type& impl, asio::error_code& ec)
method async_wait (line 230) | void async_wait(implementation_type& impl,
method do_wait (line 253) | void do_wait(const Duration& timeout, asio::error_code& ec)
FILE: src/third_party/asio/detail/dependent_type.hpp
type asio (line 22) | namespace asio {
type detail (line 23) | namespace detail {
type dependent_type (line 26) | struct dependent_type
FILE: src/third_party/asio/detail/descriptor_ops.hpp
type asio (line 31) | namespace asio {
type detail (line 32) | namespace detail {
type descriptor_ops (line 33) | namespace descriptor_ops {
function ReturnType (line 54) | inline ReturnType error_wrapper(ReturnType return_value,
FILE: src/third_party/asio/detail/descriptor_read_op.hpp
type asio (line 32) | namespace asio {
type detail (line 33) | namespace detail {
class descriptor_read_op_base (line 36) | class descriptor_read_op_base : public reactor_op
method descriptor_read_op_base (line 39) | descriptor_read_op_base(int descriptor,
method status (line 47) | static status do_perform(reactor_op* base)
class descriptor_read_op (line 70) | class descriptor_read_op
method descriptor_read_op (line 76) | descriptor_read_op(int descriptor, const MutableBufferSequence& bu...
method do_complete (line 86) | static void do_complete(void* owner, operation* base,
FILE: src/third_party/asio/detail/descriptor_write_op.hpp
type asio (line 32) | namespace asio {
type detail (line 33) | namespace detail {
class descriptor_write_op_base (line 36) | class descriptor_write_op_base : public reactor_op
method descriptor_write_op_base (line 39) | descriptor_write_op_base(int descriptor,
method status (line 47) | static status do_perform(reactor_op* base)
class descriptor_write_op (line 70) | class descriptor_write_op
method descriptor_write_op (line 76) | descriptor_write_op(int descriptor, const ConstBufferSequence& buf...
method do_complete (line 86) | static void do_complete(void* owner, operation* base,
FILE: src/third_party/asio/detail/dev_poll_reactor.hpp
type asio (line 40) | namespace asio {
type detail (line 41) | namespace detail {
class dev_poll_reactor (line 43) | class dev_poll_reactor
type op_types (line 47) | enum op_types { read_op = 0, write_op = 1,
type per_descriptor_data (line 51) | struct per_descriptor_data
method post_immediate_completion (line 87) | void post_immediate_completion(reactor_op* op, bool is_continuation)
FILE: src/third_party/asio/detail/epoll_reactor.hpp
type asio (line 41) | namespace asio {
type detail (line 42) | namespace detail {
class epoll_reactor (line 44) | class epoll_reactor
type op_types (line 52) | enum op_types { read_op = 0, write_op = 1,
class descriptor_state (line 56) | class descriptor_state : operation
method set_ready_events (line 73) | void set_ready_events(uint32_t events) { task_result_ = events; }
method add_ready_events (line 74) | void add_ready_events(uint32_t events) { task_result_ |= events; }
method post_immediate_completion (line 117) | void post_immediate_completion(reactor_op* op, bool is_continuation)
type perform_io_cleanup_on_block_exit (line 250) | struct perform_io_cleanup_on_block_exit
FILE: src/third_party/asio/detail/event.hpp
type asio (line 32) | namespace asio {
type detail (line 33) | namespace detail {
FILE: src/third_party/asio/detail/eventfd_select_interrupter.hpp
type asio (line 25) | namespace asio {
type detail (line 26) | namespace detail {
class eventfd_select_interrupter (line 28) | class eventfd_select_interrupter
method read_descriptor (line 47) | int read_descriptor() const
FILE: src/third_party/asio/detail/executor_function.hpp
type asio (line 23) | namespace asio {
type detail (line 24) | namespace detail {
class executor_function_base (line 26) | class executor_function_base
method complete (line 29) | void complete()
method destroy (line 34) | void destroy()
method executor_function_base (line 42) | executor_function_base(func_type func)
class executor_function (line 57) | class executor_function : public executor_functio
Copy disabled (too large)
Download .json
Condensed preview — 2575 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (21,122K chars).
[
{
"path": ".circleci/config.yml",
"chars": 6599,
"preview": "# Python CircleCI 2.0 configuration file\n#\n# Check https://circleci.com/docs/2.0/language-python/ for more details\n#\nver"
},
{
"path": ".clang-format",
"chars": 347,
"preview": "AccessModifierOffset: -1\nAllowShortFunctionsOnASingleLine: false\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLo"
},
{
"path": ".github/CONTRIBUTING.md",
"chars": 2092,
"preview": "# Contributing to Polygames\nWe want to make contributing to this project as easy and transparent as\npossible.\n\n## Pull R"
},
{
"path": ".github/ISSUE_TEMPLATE.md",
"chars": 283,
"preview": "## Steps to reproduce\n\n 1. _____\n 2. _____\n 3. _____\n\n## Observed Results\n\n * What happened? This could be a descri"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1177,
"preview": "## Types of changes\n\n<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->\n\n"
},
{
"path": ".gitignore",
"chars": 5963,
"preview": "# Created by https://www.gitignore.io/api/vim,c++,cmake,linux,macos,python,intellij,sublimetext\n# Edit at https://www.gi"
},
{
"path": "CMakeLists.txt",
"chars": 1810,
"preview": "CMAKE_MINIMUM_REQUIRED(VERSION 3.3)\nproject(polygames)\n\n# if(NOT CMAKE_BUILD_TYPE)\n# set(CMAKE_BUILD_TYPE RelWithDebIn"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3355,
"preview": "# Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, we as\ncontributors and"
},
{
"path": "LICENSE",
"chars": 1086,
"preview": "MIT License\n\nCopyright (c) Facebook, Inc. and its affiliates.\n\nPermission is hereby granted, free of charge, to any pers"
},
{
"path": "README.md",
"chars": 18200,
"preview": "[](https://circleci.com/gh/facebookincubat"
},
{
"path": "build.sh",
"chars": 333,
"preview": "#!/bin/sh\n# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under"
},
{
"path": "littlegolem/play_littlegolem.py",
"chars": 20068,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "nix/Dockerfile",
"chars": 2705,
"preview": "# This Dockerfile configures a Debian system with Nix, builds Polygames and\n# runs some tests. To build this docker imag"
},
{
"path": "nix/Dockerfile-centos7-nix",
"chars": 1017,
"preview": "# docker build -t polygames-centos7-nix -f Dockerfile-centos7-nix .\n# docker run --rm -it polygames-centos7-nix\n# nix-sh"
},
{
"path": "nix/README.md",
"chars": 3116,
"preview": "# Polygames for Nix users\n\n[Nix](https://nixos.org/) is a package manager that can be installed on any\nLinux distributio"
},
{
"path": "nix/get-nvidia.sh",
"chars": 516,
"preview": "#!/bin/sh\n\nnvidiaVersion=$(nvidia-smi --query-gpu=driver_version --format=csv | tail -n 1)\necho \"detected: ${nvidiaVersi"
},
{
"path": "nix/shell-cpu.nix",
"chars": 1291,
"preview": "let\n rev = \"dfa8e8b9bc4a18bab8f2c55897b6054d31e2c71b\";\n channel = fetchTarball \"https://github.com/NixOS/nixpkgs/archi"
},
{
"path": "nix/shell-cuda.nix",
"chars": 2298,
"preview": "let\n\n jsonPath = ../nvidia.json;\n hasJson = builtins.pathExists jsonPath;\n json = builtins.fromJSON (builtins.readFil"
},
{
"path": "pypolygames/__init__.py",
"chars": 823,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/__main__.py",
"chars": 19913,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/convert.py",
"chars": 10100,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/draw_model.py",
"chars": 1164,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/env_creation_helpers.py",
"chars": 7656,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/evaluation.py",
"chars": 19880,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/human.py",
"chars": 13436,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/__init__.py",
"chars": 1003,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/amazons_model.py",
"chars": 6282,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/connect4_benchmark_model.py",
"chars": 1447,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/deep_conv_conv_logit_model.py",
"chars": 5340,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/deep_conv_fc_logit_model.py",
"chars": 4945,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/generic_model.py",
"chars": 6161,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/loss.py",
"chars": 1365,
"preview": "import torch\nfrom torch import nn\nimport torch.nn.functional as F\n\nfrom typing import Tuple\n\ndef mcts_loss(\n self,\n "
},
{
"path": "pypolygames/model_zoo/nano_conv_logit_model.py",
"chars": 3771,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/nano_fc_logit_model.py",
"chars": 3386,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/res_conv_conv_logit_model.py",
"chars": 6795,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/res_conv_conv_logit_pool_model.py",
"chars": 7000,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/res_conv_conv_logit_pool_model_v2.py",
"chars": 8397,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/res_conv_fc_logit_model.py",
"chars": 6409,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/u_conv_conv_logit_model.py",
"chars": 9103,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/u_conv_fc_logit_model.py",
"chars": 8717,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/model_zoo/utils.py",
"chars": 1440,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/params.py",
"chars": 32012,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/tests/README.md",
"chars": 376,
"preview": "\n## how to use test_interactions.py\n\n- remove old ground-truth file: `rm pypolygames/tests/data/Hex11.txt`\n\n- run tests "
},
{
"path": "pypolygames/tests/__init__.py",
"chars": 199,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/tests/data/BlockGo.txt",
"chars": 7546,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Breakthrough.txt",
"chars": 1608,
"preview": "actions: ['1', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/ChineseCheckers.txt",
"chars": 14657,
"preview": "actions: ['C4', 'G35', 'A10', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/DiceShogi.txt",
"chars": 907,
"preview": "actions: ['1', '1', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Einstein.txt",
"chars": 1195,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/GameOfTheAmazons.txt",
"chars": 5893,
"preview": "actions: ['A7', 'B6', 'C6', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Havannah5.txt",
"chars": 2913,
"preview": "actions: ['0,4', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Havannah8.txt",
"chars": 6856,
"preview": "actions: ['0,7', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Hex11.txt",
"chars": 4260,
"preview": "actions: ['a1', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Hex13.txt",
"chars": 5664,
"preview": "actions: ['a1', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/KyotoShogi.txt",
"chars": 1310,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Minishogi.txt",
"chars": 1245,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Othello10.txt",
"chars": 5304,
"preview": "actions: ['G6', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Othello16.txt",
"chars": 10992,
"preview": "actions: ['J9', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/OthelloOpt10.txt",
"chars": 1061,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/OthelloOpt16.txt",
"chars": 1688,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Surakarta.txt",
"chars": 1448,
"preview": "actions: ['A5-B4', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/data/Tristannogo.txt",
"chars": 5135,
"preview": "actions: ['0', 'blublu']\n######################################################################\n# "
},
{
"path": "pypolygames/tests/test_interactions.py",
"chars": 4256,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/tests/test_mcts.py",
"chars": 3675,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/tests/test_params.py",
"chars": 1658,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/tests/test_zoo.py",
"chars": 1560,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/training.py",
"chars": 28603,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/__init__.py",
"chars": 574,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/assert_utils.py",
"chars": 1138,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/checkpoint.py",
"chars": 4969,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/command_history.py",
"chars": 2735,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/helpers.py",
"chars": 887,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/listings.py",
"chars": 1289,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/logger.py",
"chars": 825,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/multi_counter.py",
"chars": 3485,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/plotter.py",
"chars": 3181,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/restrack.py",
"chars": 2665,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/result.py",
"chars": 1054,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/utils/test_listings.py",
"chars": 859,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "pypolygames/weight_init.py",
"chars": 1186,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "singularity/README.md",
"chars": 725,
"preview": "# Polygames singularity image\n\n\nBuild an image with the following command (from polygames root directory):\n```bash\nsingu"
},
{
"path": "singularity/environment.yml",
"chars": 1314,
"preview": "name: polygames\nchannels:\n - pytorch\n - conda-forge\n - defaults\ndependencies:\n - ca-certificates=2019.6.16=hecc5488_"
},
{
"path": "singularity/polygames.def",
"chars": 2942,
"preview": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "src/CMakeLists.txt",
"chars": 2811,
"preview": " \n\ninclude_directories(${CMAKE_CURRENT_SOURCE_DIR})\ninclude_directories(third_party)\ninclude_directories(third_party/fmt"
},
{
"path": "src/common/async.h",
"chars": 6757,
"preview": "#pragma once\n\n#include <condition_variable>\n#include <deque>\n#include <functional>\n#include <future>\n#include <list>\n#in"
},
{
"path": "src/common/thread_id.cc",
"chars": 217,
"preview": "\n#include <atomic>\n\nnamespace {\nstd::atomic_int threadIdCounter{0};\nthread_local int threadId = ++threadIdCounter;\n} //"
},
{
"path": "src/common/thread_id.h",
"chars": 42,
"preview": "\nnamespace common {\n\nint getThreadId();\n}\n"
},
{
"path": "src/common/threads.cc",
"chars": 1285,
"preview": "\n#include \"threads.h\"\n\nnamespace threads {\n\nasync::Threads threads;\nstd::once_flag flag;\n\nvoid init(int nThreads) {\n\n s"
},
{
"path": "src/common/threads.h",
"chars": 195,
"preview": "\n#include \"async.h\"\n\n#include <string>\n\nnamespace threads {\n\nextern async::Threads threads;\n\nvoid init(int nThreads);\nvo"
},
{
"path": "src/core/actor.h",
"chars": 9872,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/actor_player.h",
"chars": 1903,
"preview": "#pragma once\n\n#include \"actor.h\"\n#include \"player.h\"\n\nnamespace core {\n\nclass ActorPlayer : public Player {\n public:\n A"
},
{
"path": "src/core/forward_player.h",
"chars": 503,
"preview": "#pragma once\n\n#include \"actor_player.h\"\n\nnamespace core {\n\nclass ForwardPlayer : public ActorPlayer {\n public:\n void ba"
},
{
"path": "src/core/game.cc",
"chars": 54170,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/game.h",
"chars": 22308,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/human_player.h",
"chars": 1322,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/model_manager.cc",
"chars": 28890,
"preview": "\n#include \"model_manager.h\"\n\n#include \"common/async.h\"\n#include \"common/thread_id.h\"\n#include \"distributed/distributed.h"
},
{
"path": "src/core/model_manager.h",
"chars": 2488,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/player.h",
"chars": 801,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/pybind.cc",
"chars": 4109,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/replay_buffer.cc",
"chars": 6361,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/replay_buffer.h",
"chars": 2215,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/state.cc",
"chars": 5984,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/state.h",
"chars": 17519,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/test_state.cc",
"chars": 12339,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/core/utils.h",
"chars": 7004,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/distributed/distributed.cc",
"chars": 34209,
"preview": "\n#include \"distributed.h\"\n\n#include \"rpc.h\"\n\n#include \"rdma.h\"\n\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"zstd/lib/zstd"
},
{
"path": "src/distributed/distributed.h",
"chars": 3735,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/distributed/ib.cc",
"chars": 13645,
"preview": "\n#include \"rdma.h\"\n\n#include <infiniband/verbs.h>\n\n#include <deque>\n#include <list>\n#include <optional>\n#include <random"
},
{
"path": "src/distributed/network.cc",
"chars": 22786,
"preview": "\n#include \"network.h\"\n\n#include \"asio.hpp\"\n\n#include <deque>\n#include <list>\n#include <vector>\n\nnamespace network {\n\ntem"
},
{
"path": "src/distributed/network.h",
"chars": 2043,
"preview": "#pragma once\n\n#include <functional>\n#include <memory>\n#include <mutex>\n#include <string_view>\n\nnamespace network {\n\nclas"
},
{
"path": "src/distributed/rdma.h",
"chars": 1343,
"preview": "#pragma once\n\n#include <cstddef>\n#include <cstdint>\n#include <memory>\n#include <optional>\n#include <stdexcept>\n\nnamespac"
},
{
"path": "src/distributed/rdma_nop.cc",
"chars": 115,
"preview": "#include \"rdma.h\"\n\nnamespace rdma {\n\nstd::unique_ptr<Context> create() {\n return nullptr;\n}\n\n} // namespace rdma\n"
},
{
"path": "src/distributed/rpc.h",
"chars": 15803,
"preview": "\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"zstd/lib/zstd.h\"\n\n#include \"network.h\"\n\n#include \"string_view\"\n\n#include <at"
},
{
"path": "src/games/amazons.cc",
"chars": 9802,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/amazons.h",
"chars": 3125,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/block_go.h",
"chars": 16183,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/breakthrough.cc",
"chars": 1112,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/breakthrough.h",
"chars": 12012,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/breakthrough_state.h",
"chars": 5654,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/chess.cc",
"chars": 16810,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/chess.h",
"chars": 6635,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/chinesecheckers.cc",
"chars": 20590,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/chinesecheckers.h",
"chars": 10524,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/chinesecheckers_defines.h",
"chars": 2426,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/commons/chessboard.h",
"chars": 10208,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/commons/hash.h",
"chars": 1127,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/commons/player.h",
"chars": 845,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/connect6.h",
"chars": 4583,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/connect6_state.h",
"chars": 6800,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/connectfour.h",
"chars": 3637,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/diceshogi.h",
"chars": 17217,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/diceshogi_state.h",
"chars": 31293,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/einstein.h",
"chars": 12158,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/game_action.h",
"chars": 333,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/game_base.cc",
"chars": 234,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/game_base.h",
"chars": 1692,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/game_player.h",
"chars": 641,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/game_state.h",
"chars": 329,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/gomoku_swap2.cc",
"chars": 5310,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/gomoku_swap2.h",
"chars": 2456,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/havannah.h",
"chars": 19243,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/havannah_state.h",
"chars": 8323,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/hex.h",
"chars": 13062,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/hex_state.h",
"chars": 6034,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/kyotoshogi.h",
"chars": 16617,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/kyotoshogi_state.h",
"chars": 25606,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/ludii/README.md",
"chars": 3941,
"preview": "# Polygames + Ludii integration\n\nWe have implemented a bridge between Polygames' tree search and learning algorithms, an"
},
{
"path": "src/games/ludii/jni_utils.cc",
"chars": 5087,
"preview": "// inspired from\n// https://gist.github.com/alexminnaar/90cf1ea3de45e79a1b14081d90d214b7\n\n/*\nCopyright (c) 2020 Alex Min"
},
{
"path": "src/games/ludii/jni_utils.h",
"chars": 2441,
"preview": "// strongly inspired from\n// https://gist.github.com/alexminnaar/90cf1ea3de45e79a1b14081d90d214b7 might\n// need somethin"
},
{
"path": "src/games/ludii/ludii_game_wrapper.cc",
"chars": 9384,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/ludii/ludii_game_wrapper.h",
"chars": 3203,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/ludii/ludii_state_wrapper.cc",
"chars": 11702,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/ludii/ludii_state_wrapper.h",
"chars": 4407,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/mastermind_state.cc",
"chars": 262,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/mastermind_state.h",
"chars": 12011,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper.cc",
"chars": 925,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_common.h",
"chars": 7192,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_csp_vkms/CMakeLists.txt",
"chars": 663,
"preview": "CMAKE_MINIMUM_REQUIRED(VERSION 3.3)\nproject(csp_vkms)\n\nset(CMAKE_CXX_STANDARD 17)\n\nif (${Torch_FOUND})\n include_directo"
},
{
"path": "src/games/minesweeper_csp_vkms/ConnectedComponent.h",
"chars": 476,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_csp_vkms/CspStrategy.h",
"chars": 17894,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_csp_vkms/SolutionSet.h",
"chars": 18729,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_csp_vkms/SolutionSetSampler.h",
"chars": 16411,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_csp_vkms/csp_vkms.cc",
"chars": 2338,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minesweeper_state.h",
"chars": 15730,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/minishogi.h",
"chars": 17534,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/mnkgame.h",
"chars": 9259,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_action.cc",
"chars": 1911,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_action.h",
"chars": 1251,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_bitboard.h",
"chars": 2492,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_game.cc",
"chars": 4890,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_game.h",
"chars": 1920,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_position.h",
"chars": 4325,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_state.cc",
"chars": 7789,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_state.h",
"chars": 1301,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/nogo_zestate.h",
"chars": 4973,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/othello.h",
"chars": 11924,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/othello_opt.cc",
"chars": 11804,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/othello_opt.h",
"chars": 2759,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/outeropengomoku_new.h",
"chars": 4014,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/shogi.h",
"chars": 34511,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/surakarta.h",
"chars": 10535,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/surakarta_state.h",
"chars": 6670,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/tristan_nogo.cc",
"chars": 1154,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/tristan_nogo.h",
"chars": 19123,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/tristannogo_state.h",
"chars": 5530,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/SchurMatrix.cpp",
"chars": 954,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/SchurMatrix.hpp",
"chars": 711,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/SchurVector.cpp",
"chars": 741,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/SchurVector.hpp",
"chars": 560,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/WeakSchur.cpp",
"chars": 5682,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/WeakSchur.hpp",
"chars": 1811,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/weakschur/weakschur_state.h",
"chars": 7092,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/yinsh.cc",
"chars": 29213,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/games/yinsh.h",
"chars": 2533,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/mcts/CMakeLists.txt",
"chars": 626,
"preview": "cmake_minimum_required(VERSION 3.0 FATAL_ERROR)\n\n# lib for other c++ programs\nadd_library(_mcts\n node.cc\n mcts.cc\n st"
},
{
"path": "src/mcts/actor.h",
"chars": 1071,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/mcts/mcts.cc",
"chars": 18903,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/mcts/mcts.h",
"chars": 1865,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/mcts/node.cc",
"chars": 2011,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
},
{
"path": "src/mcts/node.h",
"chars": 2623,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n *\n * This source code is licensed under th"
}
]
// ... and 2375 more files (download for full content)
About this extraction
This page contains the full source code of the facebookincubator/Polygames GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2575 files (19.2 MB), approximately 5.2M tokens, and a symbol index with 26049 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.