Copy disabled (too large)
Download .txt
Showing preview only (14,214K chars total). Download the full file to get everything.
Repository: parapluu/Concuerror
Branch: master
Commit: c90d601808a0
Files: 1282
Total size: 13.3 MB
Directory structure:
gitextract_f2h5wf0f/
├── .editorconfig
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── feature_request.md
│ │ └── other-issue.md
│ ├── codecov.yml
│ ├── pull_request_template.md
│ ├── scripts/
│ │ ├── covertool_combine
│ │ └── covertool_setup
│ └── workflows/
│ ├── tests.yml
│ └── website.yml
├── .gitignore
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── bin/
│ └── .gitignore
├── cover/
│ ├── .gitignore
│ └── cover-report
├── doc/
│ ├── .gitignore
│ ├── Gemfile
│ ├── Makefile
│ └── overview.edoc
├── docs/
│ ├── .bundle/
│ │ └── config
│ ├── .gitignore
│ ├── 404.md
│ ├── CNAME
│ ├── Gemfile
│ ├── Makefile
│ ├── README.md
│ ├── _config.yml
│ ├── _config_local.yml
│ ├── _data/
│ │ ├── authors.yml
│ │ ├── navigation.yml
│ │ └── text.yml
│ ├── _includes/
│ │ ├── footer-custom.html
│ │ ├── head-custom.html
│ │ ├── masthead.html
│ │ └── yt.html
│ ├── _posts/
│ │ ├── 2013-09-03-site.md
│ │ ├── 2013-09-23-euc-2013.md
│ │ ├── 2014-06-02-poolboy-example.md
│ │ ├── 2014-06-03-poolboy-example-errors.md
│ │ ├── 2014-08-11-euc-2014.md
│ │ ├── 2015-06-10-euc-2015.md
│ │ ├── 2017-08-14-euc-2017-talk.md
│ │ ├── 2017-08-14-euc-2017-tutorial.md
│ │ ├── 2017-10-03-publications-update.md
│ │ ├── 2017-10-08-concuerror-eunit.md
│ │ ├── 2017-10-14-concuerring-concuerror-ep-1.md
│ │ ├── 2017-11-06-Announcing-Mailing-List.md
│ │ ├── 2018-07-15-hex.md
│ │ ├── 2020-10-10-tips.md
│ │ ├── 2020-10-17-code-beam-sf-2019.md
│ │ ├── 2020-10-17-functional-conf-2018.md
│ │ └── 2020-10-24-basic-tutorial.md
│ ├── contact.md
│ ├── download.md
│ ├── faq.md
│ ├── feed.xml
│ ├── index.md
│ ├── news.md
│ ├── publications.md
│ ├── search.md
│ ├── sitemap.xml
│ └── tutorials.md
├── elvis.config
├── priv/
│ ├── concuerror
│ ├── generate_option_docfiles
│ └── generate_version_hrl
├── rebar.config
├── resources/
│ ├── DPOR_paper_material/
│ │ ├── DPOR_README
│ │ ├── foo.erl
│ │ ├── foobar.erl
│ │ ├── my_test.erl
│ │ ├── run_dialyzer.sh
│ │ ├── run_filesystem.sh
│ │ ├── run_indexer.sh
│ │ ├── run_last_zero.sh
│ │ ├── run_readers.sh
│ │ └── run_rush_hour.sh
│ ├── bash_completion/
│ │ └── concuerror
│ ├── erlang_questions/
│ │ └── dets_bugs/
│ │ ├── alt_dets_bugs.erl
│ │ └── dets_bugs.erl
│ ├── flanagan.erl
│ ├── how-to-release.md
│ ├── old_include/
│ │ ├── gen.hrl
│ │ ├── gui.hrl
│ │ └── instr.hrl
│ ├── old_source/
│ │ ├── LICENSE
│ │ ├── concuerror.erl
│ │ ├── concuerror_deps.erl
│ │ ├── concuerror_error.erl
│ │ ├── concuerror_gui.erl
│ │ ├── concuerror_instr.erl
│ │ ├── concuerror_io_server.erl
│ │ ├── concuerror_lid.erl
│ │ ├── concuerror_log.erl
│ │ ├── concuerror_proc_action.erl
│ │ ├── concuerror_rep.erl
│ │ ├── concuerror_sched.erl
│ │ ├── concuerror_state.erl
│ │ ├── concuerror_ticket.erl
│ │ └── concuerror_util.erl
│ ├── perm_tests/
│ │ ├── run_perm_tests
│ │ └── src/
│ │ ├── complete_test_3.erl
│ │ ├── conditional_readers_3.erl
│ │ ├── depend_4_1.erl
│ │ ├── depend_4_2.erl
│ │ ├── depend_4_3.erl
│ │ ├── depend_6_1.erl
│ │ ├── depend_6_2.erl
│ │ ├── depend_6_3.erl
│ │ ├── depend_6_4.erl
│ │ ├── depend_6_5.erl
│ │ ├── etsi.erl
│ │ ├── readers_2.erl
│ │ └── readers_3.erl
│ ├── syntax/
│ │ ├── block_after.erl
│ │ ├── non_local_pat.erl
│ │ ├── rec_uscore.erl
│ │ └── strip_attr.erl
│ ├── tdd/
│ │ ├── reg_server.erl
│ │ ├── reg_server.hrl
│ │ └── reg_server_tests.erl
│ └── utest/
│ ├── concuerror_error_tests.erl
│ ├── concuerror_instr_tests.erl
│ ├── concuerror_lid_tests.erl
│ ├── concuerror_state_tests.erl
│ └── concuerror_ticket_tests.erl
├── src/
│ ├── .gitignore
│ ├── concuerror.app.src
│ ├── concuerror.erl
│ ├── concuerror.hrl
│ ├── concuerror_callback.erl
│ ├── concuerror_dependencies.erl
│ ├── concuerror_estimator.erl
│ ├── concuerror_inspect.erl
│ ├── concuerror_instrumenter.erl
│ ├── concuerror_io_lib.erl
│ ├── concuerror_loader.erl
│ ├── concuerror_logger.erl
│ ├── concuerror_options.erl
│ ├── concuerror_scheduler.erl
│ └── concuerror_window_average.erl
├── test/
│ ├── README.md
│ ├── concuerror_logger_tests.erl
│ └── concuerror_options_tests.erl
├── tests/
│ ├── README.md
│ ├── differ
│ ├── results/
│ │ └── .gitignore
│ ├── runtests.py
│ ├── scenarios.erl
│ ├── suites/
│ │ ├── advanced_tests/
│ │ │ ├── results/
│ │ │ │ ├── gen_server_bug-test_register-inf-dpor.txt
│ │ │ │ ├── gen_server_bug-test_without_register-inf-dpor.txt
│ │ │ │ ├── manolis-test_2workers_small-inf-dpor.txt
│ │ │ │ ├── percept-test-inf-dpor.txt
│ │ │ │ ├── preemption-preemption-inf-dpor.txt
│ │ │ │ ├── receive_deps-test-inf-dpor.txt
│ │ │ │ ├── receive_deps_kill-test-inf-dpor.txt
│ │ │ │ ├── receive_pats-test1-inf-dpor.txt
│ │ │ │ ├── receive_pats-test2-inf-dpor.txt
│ │ │ │ ├── receive_pats-test3-inf-dpor.txt
│ │ │ │ ├── receive_pats-test4-inf-dpor.txt
│ │ │ │ ├── receive_patterns-test1-inf-optimal.txt
│ │ │ │ ├── receive_patterns-test2-inf-optimal.txt
│ │ │ │ ├── ring_leader_election-ring_leader_election-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_barrier-ring_leader_election_barrier-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric-ring_leader_election_symmetric-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric_buffer-ring_leader_election_symmetric_buffer-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric_buffer_2-ring_leader_election_symmetric_buffer_2-inf-dpor.txt
│ │ │ │ ├── shared_ptr-shared_ptr-inf-dpor.txt
│ │ │ │ ├── shootout-test1-inf-dpor.txt
│ │ │ │ ├── simple_registry-simple_registry-inf-dpor.txt
│ │ │ │ ├── source_killer-test-inf-dpor.txt
│ │ │ │ ├── source_killer-test-inf-source.txt
│ │ │ │ └── vjeko_peer-concuerror_test-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── gen_server_bug.erl
│ │ │ ├── indexer_example.erl
│ │ │ ├── manolis/
│ │ │ │ ├── good_testcase.txt
│ │ │ │ ├── readme.txt
│ │ │ │ ├── rush_hour.erl
│ │ │ │ ├── search.erl
│ │ │ │ └── test.erl
│ │ │ ├── percept.erl
│ │ │ ├── preemption.erl
│ │ │ ├── receive_deps.erl
│ │ │ ├── receive_deps_kill.erl
│ │ │ ├── receive_pats.erl
│ │ │ ├── receive_patterns.erl
│ │ │ ├── ring_leader_election.erl
│ │ │ ├── ring_leader_election_barrier.erl
│ │ │ ├── ring_leader_election_symmetric.erl
│ │ │ ├── ring_leader_election_symmetric_buffer.erl
│ │ │ ├── ring_leader_election_symmetric_buffer_2.erl
│ │ │ ├── send_order.erl
│ │ │ ├── shared_ptr.erl
│ │ │ ├── shootout/
│ │ │ │ ├── pidigits.erl
│ │ │ │ ├── test.erl
│ │ │ │ └── thread_ring.erl
│ │ │ ├── simple_registry.erl
│ │ │ ├── source_killer.erl
│ │ │ └── vjeko_peer.erl
│ │ ├── basic_tests/
│ │ │ ├── results/
│ │ │ │ ├── ac_tab_insert-test-inf-optimal.txt
│ │ │ │ ├── after_test_2-after_test_2-inf-dpor.txt
│ │ │ │ ├── after_test_3-after_test_3-inf-dpor.txt
│ │ │ │ ├── after_vs_trap_exit-after_vs_trap_exit-inf-dpor.txt
│ │ │ │ ├── allow_first_crash-test-inf-dpor.txt
│ │ │ │ ├── assert_filter-test-inf-dpor.txt
│ │ │ │ ├── bad_dictionary-bad_erase-inf-optimal.txt
│ │ │ │ ├── bad_dictionary-bad_get-inf-optimal.txt
│ │ │ │ ├── bad_dictionary-bad_put-inf-optimal.txt
│ │ │ │ ├── bad_whereis-test-inf-dpor.txt
│ │ │ │ ├── code_when_undef-test-inf-optimal.txt
│ │ │ │ ├── concuerror_crash-test-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test1-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test2-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test3-inf-dpor.txt
│ │ │ │ ├── dead_receive-dead_receive-inf-dpor.txt
│ │ │ │ ├── deeper_exit-test-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_both-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_flush-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_info-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_none-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_both-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_flush-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_info-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_none-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test1-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test2-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test3-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test4-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test5-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test6-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test1-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test2-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test3-inf-dpor.txt
│ │ │ │ ├── depth_bound-test-inf-dpor.txt
│ │ │ │ ├── erlang_display-test-inf-dpor.txt
│ │ │ │ ├── erlang_display_string-test-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete_bad-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete_plain-inf-dpor.txt
│ │ │ │ ├── ets_delete_2-ets_delete_2-inf-dpor.txt
│ │ │ │ ├── ets_delete_2-ets_delete_2_twice-inf-dpor.txt
│ │ │ │ ├── ets_delete_all-delete_all_bad-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-delete_all_good-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-race_delete_all_read-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-race_delete_all_write-inf-optimal.txt
│ │ │ │ ├── ets_delete_object-test1-inf-dpor.txt
│ │ │ │ ├── ets_delete_object-test2-inf-dpor.txt
│ │ │ │ ├── ets_delete_object-test3-inf-dpor.txt
│ │ │ │ ├── ets_exceptions-test-inf-dpor.txt
│ │ │ │ ├── ets_give_away-give_away_bad-inf-optimal.txt
│ │ │ │ ├── ets_give_away-give_away_good-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_delete-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_exit-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_new-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_rename_free-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_rename_taken-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_delete-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_exit-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_rename_free-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_rename_taken-inf-optimal.txt
│ │ │ │ ├── ets_heir-ets_heir-inf-dpor.txt
│ │ │ │ ├── ets_heir-test-inf-dpor.txt
│ │ │ │ ├── ets_heir-test1-inf-dpor.txt
│ │ │ │ ├── ets_heir-test2-inf-dpor.txt
│ │ │ │ ├── ets_heir_2-ets_heir_2-inf-dpor.txt
│ │ │ │ ├── ets_info-info_2_badarg-inf-optimal.txt
│ │ │ │ ├── ets_info-info_bad-inf-optimal.txt
│ │ │ │ ├── ets_info-info_badarg-inf-optimal.txt
│ │ │ │ ├── ets_info-info_good-inf-optimal.txt
│ │ │ │ ├── ets_info-info_system-inf-optimal.txt
│ │ │ │ ├── ets_info_details-test-inf-optimal.txt
│ │ │ │ ├── ets_insert_new-test-inf-dpor.txt
│ │ │ │ ├── ets_insert_objects-ets_insert_objects-inf-dpor.txt
│ │ │ │ ├── ets_many_insert_new-ets_many_insert_new-inf-dpor.txt
│ │ │ │ ├── ets_new-test-inf-dpor.txt
│ │ │ │ ├── ets_new-test-inf.txt
│ │ │ │ ├── ets_new_failure-ets_new_failure-inf-dpor.txt
│ │ │ │ ├── ets_new_failure_2-ets_new_failure_2-inf-dpor.txt
│ │ │ │ ├── ets_new_failure_3-ets_new_failure_3-inf-dpor.txt
│ │ │ │ ├── ets_ref_keys-ets_ref_keys-0.txt
│ │ │ │ ├── ets_ref_keys-ets_ref_keys-inf-dpor.txt
│ │ │ │ ├── ets_rename-rename_bad-inf-optimal.txt
│ │ │ │ ├── ets_rename-rename_good-inf-optimal.txt
│ │ │ │ ├── ets_rename-rename_public-inf-optimal.txt
│ │ │ │ ├── ets_select-match_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_any-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_any-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_unguarded-test-inf-optimal.txt
│ │ │ │ ├── ets_unnamed-test1-inf-dpor.txt
│ │ │ │ ├── ets_unnamed-test2-inf-dpor.txt
│ │ │ │ ├── ets_unnamed-test3-inf-dpor.txt
│ │ │ │ ├── ets_update_counter-test-inf-dpor.txt
│ │ │ │ ├── ets_update_counter-test1-inf-dpor.txt
│ │ │ │ ├── ets_update_element-race_update_element_r-inf-optimal.txt
│ │ │ │ ├── ets_update_element-race_update_element_w-inf-optimal.txt
│ │ │ │ ├── ets_update_element-update_element_bad-inf-optimal.txt
│ │ │ │ ├── ets_update_element-update_element_good-inf-optimal.txt
│ │ │ │ ├── ets_whereis-race_whereis_r-inf-optimal.txt
│ │ │ │ ├── ets_whereis-race_whereis_w-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_bad-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_badarg-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_good-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_del-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_exit-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_wr-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_ww-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_system-inf-optimal.txt
│ │ │ │ ├── exit-test1-inf-dpor.txt
│ │ │ │ ├── exit-test1-inf.txt
│ │ │ │ ├── exit-test2-inf-dpor.txt
│ │ │ │ ├── exit-test2-inf.txt
│ │ │ │ ├── exit-test3-inf-dpor.txt
│ │ │ │ ├── exit-test3-inf.txt
│ │ │ │ ├── exit-test4-inf-dpor.txt
│ │ │ │ ├── exit-test5-inf-dpor.txt
│ │ │ │ ├── exit-test6-inf-dpor.txt
│ │ │ │ ├── exit_kill-test-inf-dpor.txt
│ │ │ │ ├── exit_message_unpredicted-exit_message_unpredicted-inf-dpor.txt
│ │ │ │ ├── file_read_file-test-inf-dpor.txt
│ │ │ │ ├── fun_fail-test1-inf-dpor.txt
│ │ │ │ ├── fun_fail-test2-inf-dpor.txt
│ │ │ │ ├── fun_fail-test3-inf-dpor.txt
│ │ │ │ ├── group_leader-test-inf-dpor.txt
│ │ │ │ ├── group_leader-test1-inf-dpor.txt
│ │ │ │ ├── group_leader2-test-inf-dpor.txt
│ │ │ │ ├── group_leader3-test-inf-dpor.txt
│ │ │ │ ├── halt_error-test1-inf-optimal.txt
│ │ │ │ ├── halt_error-test2-inf-optimal.txt
│ │ │ │ ├── hibernate-test-inf-optimal.txt
│ │ │ │ ├── hopeless_after-hopeless_after-inf-dpor.txt
│ │ │ │ ├── i_hate_myself-i_hate_myself-inf-dpor.txt
│ │ │ │ ├── ignore_error_1-test-inf-dpor.txt
│ │ │ │ ├── ignore_error_2-test-inf-dpor.txt
│ │ │ │ ├── ignore_error_3-test-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test1-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test2-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test3-inf-dpor.txt
│ │ │ │ ├── init_race_condition-test-inf-dpor.txt
│ │ │ │ ├── init_race_condition-test-inf.txt
│ │ │ │ ├── inspect_system-test-inf-dpor.txt
│ │ │ │ ├── instr_apply-test-inf-dpor.txt
│ │ │ │ ├── instr_apply-test-inf.txt
│ │ │ │ ├── io_error-test-inf-dpor.txt
│ │ │ │ ├── io_format-test-inf-dpor.txt
│ │ │ │ ├── io_format_2-test-inf-dpor.txt
│ │ │ │ ├── io_format_3-test-inf-dpor.txt
│ │ │ │ ├── irrelevant_send-irrelevant_send-inf-dpor.txt
│ │ │ │ ├── is_process_alive_1-is_process_alive_1-inf-dpor.txt
│ │ │ │ ├── keep_going-test-inf-dpor.txt
│ │ │ │ ├── kill_running_waiting-test-inf-dpor.txt
│ │ │ │ ├── late_hope-late_hope-inf-dpor.txt
│ │ │ │ ├── lid_test-test-inf-dpor.txt
│ │ │ │ ├── link_after-link_after-inf-dpor.txt
│ │ │ │ ├── load_before_start-test-inf-dpor.txt
│ │ │ │ ├── main_and_backup-main_and_backup-inf-dpor.txt
│ │ │ │ ├── many_kill-test-inf-dpor.txt
│ │ │ │ ├── many_links-many_links-inf-dpor.txt
│ │ │ │ ├── many_monitors-many_monitors-inf-dpor.txt
│ │ │ │ ├── many_send_to_dead-many_send_to_dead-inf-dpor.txt
│ │ │ │ ├── many_send_to_dead_2-many_send_to_dead_2-inf-dpor.txt
│ │ │ │ ├── message_queue_length-test-inf-optimal.txt
│ │ │ │ ├── messed_deliveries-test-inf-dpor.txt
│ │ │ │ ├── module_loaded_dep-test-inf-optimal.txt
│ │ │ │ ├── monitor_demonitor-monitor_demonitor-inf-dpor.txt
│ │ │ │ ├── monitor_failure-monitor_failure-inf-dpor.txt
│ │ │ │ ├── monitor_info-test1-inf-dpor.txt
│ │ │ │ ├── monitor_info-test2-inf-dpor.txt
│ │ │ │ ├── monitor_missing_messages-monitor_missing_messages-inf-dpor.txt
│ │ │ │ ├── monitor_named-test-inf-dpor.txt
│ │ │ │ ├── monitor_order-test-inf-optimal.txt
│ │ │ │ ├── monotonic_time-test-inf-optimal.txt
│ │ │ │ ├── node_names-test1-inf-dpor.txt
│ │ │ │ ├── node_names-test2-inf-dpor.txt
│ │ │ │ ├── normal_exit-normal_exit-inf-dpor.txt
│ │ │ │ ├── normal_shutdown-test-inf-dpor.txt
│ │ │ │ ├── normal_tuple_exit-test-inf-dpor.txt
│ │ │ │ ├── os_timestamp-test-inf-dpor.txt
│ │ │ │ ├── pids_are_unsafe-test-inf-dpor.txt
│ │ │ │ ├── process_flag_link-process_flag_link-inf-dpor.txt
│ │ │ │ ├── process_info-test1-inf-dpor.txt
│ │ │ │ ├── process_info-test2-inf-dpor.txt
│ │ │ │ ├── process_info-test3-inf-dpor.txt
│ │ │ │ ├── process_info-test_current_function-inf-dpor.txt
│ │ │ │ ├── process_info-test_current_function_top-inf-dpor.txt
│ │ │ │ ├── process_info-test_message_queue_len-inf-dpor.txt
│ │ │ │ ├── process_info-test_messages-inf-dpor.txt
│ │ │ │ ├── process_info-test_mql_flush-inf-dpor.txt
│ │ │ │ ├── processes-test1-inf-dpor.txt
│ │ │ │ ├── processes-test2-inf-dpor.txt
│ │ │ │ ├── processes_leader-test-inf-optimal.txt
│ │ │ │ ├── racing_after-test-inf-dpor.txt
│ │ │ │ ├── receive_after-receive_after-inf-dpor.txt
│ │ │ │ ├── receive_and_after-receive_and_after-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test1-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test2-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test3-inf-dpor.txt
│ │ │ │ ├── receive_exit-test-inf-dpor.txt
│ │ │ │ ├── receive_exit-test1-inf-dpor.txt
│ │ │ │ ├── receive_exit-test2-inf-dpor.txt
│ │ │ │ ├── receive_exit-test3-inf-dpor.txt
│ │ │ │ ├── receive_with_guard-receive_with_guard-inf-dpor.txt
│ │ │ │ ├── receive_without_trapping-receive_without_trapping-inf-dpor.txt
│ │ │ │ ├── register_link-test-inf-optimal.txt
│ │ │ │ ├── registered_1-registered_1-inf-dpor.txt
│ │ │ │ ├── registered_2-registered_2-inf-dpor.txt
│ │ │ │ ├── registered_send_1-registered_send_1-inf-dpor.txt
│ │ │ │ ├── registered_send_2-registered_send_2-inf-dpor.txt
│ │ │ │ ├── registered_send_3-registered_send_3-inf-dpor.txt
│ │ │ │ ├── replay_sanity-replay_sanity-inf-dpor.txt
│ │ │ │ ├── report_blocks-test-inf-dpor.txt
│ │ │ │ ├── reuse_raw_pid-test-inf-dpor.txt
│ │ │ │ ├── safeops_coverage-test-inf-optimal.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-2-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-2.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-0.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-1-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-1.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-2-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-2.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-3-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-3.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-4-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-4.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-5-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-5.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-6-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-6.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-7-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-7.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-inf.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-0-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-0.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-1-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-1.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-2-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-2.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-3-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-3.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-inf.txt
│ │ │ │ ├── sched_tests-test_halt_0-0-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_0-0.txt
│ │ │ │ ├── sched_tests-test_halt_0-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_0-inf.txt
│ │ │ │ ├── sched_tests-test_halt_1-0-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_1-0.txt
│ │ │ │ ├── sched_tests-test_halt_1-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_1-inf.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_link_unlink-0-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-0.txt
│ │ │ │ ├── sched_tests-test_link_unlink-1-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-1.txt
│ │ │ │ ├── sched_tests-test_link_unlink-2-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-2.txt
│ │ │ │ ├── sched_tests-test_link_unlink-3-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-3.txt
│ │ │ │ ├── sched_tests-test_link_unlink-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-inf.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-0-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-0.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-1-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-1.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-inf.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-0-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-0.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-1-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-1.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-2-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-2.txt
│ │ │ │ ├── sched_tests-test_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive-0.txt
│ │ │ │ ├── sched_tests-test_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive-inf.txt
│ │ │ │ ├── sched_tests-test_receive_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_2-0.txt
│ │ │ │ ├── sched_tests-test_receive_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_2-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-1-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-1.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-2-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-2.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-1-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-1.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-2-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-2.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-3-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-3.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-inf.txt
│ │ │ │ ├── sched_tests-test_register_unregister-0-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-0.txt
│ │ │ │ ├── sched_tests-test_register_unregister-1-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-1.txt
│ │ │ │ ├── sched_tests-test_register_unregister-2-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-2.txt
│ │ │ │ ├── sched_tests-test_register_unregister-3-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-3.txt
│ │ │ │ ├── sched_tests-test_register_unregister-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-inf.txt
│ │ │ │ ├── sched_tests-test_send-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send-0.txt
│ │ │ │ ├── sched_tests-test_send-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send-1.txt
│ │ │ │ ├── sched_tests-test_send-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send-inf.txt
│ │ │ │ ├── sched_tests-test_send_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-0.txt
│ │ │ │ ├── sched_tests-test_send_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-1.txt
│ │ │ │ ├── sched_tests-test_send_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-inf.txt
│ │ │ │ ├── sched_tests-test_send_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-0.txt
│ │ │ │ ├── sched_tests-test_send_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-1.txt
│ │ │ │ ├── sched_tests-test_send_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-0.txt
│ │ │ │ ├── sched_tests-test_send_receive-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-1.txt
│ │ │ │ ├── sched_tests-test_send_receive-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-2.txt
│ │ │ │ ├── sched_tests-test_send_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-0.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-1.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-2.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-0.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-1.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-2.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-0.txt
│ │ │ │ ├── sched_tests-test_spawn-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-1.txt
│ │ │ │ ├── sched_tests-test_spawn-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-2-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-2.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-0.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-1.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-2-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-2.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-inf.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-0-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-0.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-1-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-1.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-inf.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-0-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-0.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-1-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-1.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-inf.txt
│ │ │ │ ├── sched_tests-test_whereis-0-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-0.txt
│ │ │ │ ├── sched_tests-test_whereis-1-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-1.txt
│ │ │ │ ├── sched_tests-test_whereis-2-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-2.txt
│ │ │ │ ├── sched_tests-test_whereis-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-inf.txt
│ │ │ │ ├── self_exits-test1-inf-dpor.txt
│ │ │ │ ├── self_exits-test2-inf-dpor.txt
│ │ │ │ ├── self_exits-test3-inf-dpor.txt
│ │ │ │ ├── self_exits-test4-inf-dpor.txt
│ │ │ │ ├── send_after-test1-inf-dpor.txt
│ │ │ │ ├── send_after-test11-inf-dpor.txt
│ │ │ │ ├── send_after-test12-inf-dpor.txt
│ │ │ │ ├── send_after-test13-inf-dpor.txt
│ │ │ │ ├── send_after-test14-inf-dpor.txt
│ │ │ │ ├── send_after-test15-inf-dpor.txt
│ │ │ │ ├── send_after-test16-inf-dpor.txt
│ │ │ │ ├── send_after-test17-inf-dpor.txt
│ │ │ │ ├── send_after-test18-inf-dpor.txt
│ │ │ │ ├── send_after-test19-inf-dpor.txt
│ │ │ │ ├── send_after-test1A-inf-dpor.txt
│ │ │ │ ├── send_after-test1B-inf-dpor.txt
│ │ │ │ ├── send_after-test1C-inf-dpor.txt
│ │ │ │ ├── send_after-test1D-inf-dpor.txt
│ │ │ │ ├── send_after-test2-inf-dpor.txt
│ │ │ │ ├── send_after-test3-inf-dpor.txt
│ │ │ │ ├── send_after-test4-inf-dpor.txt
│ │ │ │ ├── send_after-test5-inf-dpor.txt
│ │ │ │ ├── send_after-test6-inf-dpor.txt
│ │ │ │ ├── send_after-test7-inf-dpor.txt
│ │ │ │ ├── send_after-test8-inf-dpor.txt
│ │ │ │ ├── send_after-test9-inf-dpor.txt
│ │ │ │ ├── send_after-testA-inf-dpor.txt
│ │ │ │ ├── send_after-testB-inf-dpor.txt
│ │ │ │ ├── send_after-testC-inf-dpor.txt
│ │ │ │ ├── send_after_trouble-test-inf-dpor.txt
│ │ │ │ ├── send_named_vs_send-send_named_vs_send-inf-dpor.txt
│ │ │ │ ├── send_receive_dependencies-send_receive_dependencies-inf-dpor.txt
│ │ │ │ ├── send_self-test-inf-dpor.txt
│ │ │ │ ├── send_self-test1-inf-dpor.txt
│ │ │ │ ├── send_self-test2-inf-dpor.txt
│ │ │ │ ├── send_self-test3-inf-dpor.txt
│ │ │ │ ├── send_using_names-send_using_names-inf-dpor.txt
│ │ │ │ ├── send_vs_trap_exit-send_vs_trap_exit-inf-dpor.txt
│ │ │ │ ├── signals_vs_messages-test-inf-dpor.txt
│ │ │ │ ├── signals_vs_messages-test1-inf-dpor.txt
│ │ │ │ ├── simple_ets-simple_ets-inf-dpor.txt
│ │ │ │ ├── simple_spawn-simple_spawn-inf-dpor.txt
│ │ │ │ ├── sleep_set_block_not_bad-test-inf-persistent.txt
│ │ │ │ ├── spawn_and_send-spawn_and_send-inf-dpor.txt
│ │ │ │ ├── spawn_bad-test-inf-dpor.txt
│ │ │ │ ├── spawn_failure-spawn_failure-inf-dpor.txt
│ │ │ │ ├── spawn_monitor_test-spawn_monitor_test-inf-dpor.txt
│ │ │ │ ├── spawned_sender_crasher-spawned_sender_crasher-inf-dpor.txt
│ │ │ │ ├── spawned_senders-spawned_senders-inf-dpor.txt
│ │ │ │ ├── stacktrace_vs_exit-test-inf-optimal.txt
│ │ │ │ ├── system_info-test-inf-optimal.txt
│ │ │ │ ├── system_instant_delivery-test-inf-optimal.txt
│ │ │ │ ├── system_non_instant_delivery-test-inf-optimal.txt
│ │ │ │ ├── timers_afters_exits_crashes-both_crash-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-child_crashes-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_exit_bad-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_exit_ok-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_start_timer-inf-dpor.txt
│ │ │ │ ├── timestamps-exit_system_time0-inf-optimal.txt
│ │ │ │ ├── timestamps-exit_system_time1-inf-optimal.txt
│ │ │ │ ├── timestamps-exit_timestamp-inf-optimal.txt
│ │ │ │ ├── timestamps-other_system_time0-inf-optimal.txt
│ │ │ │ ├── timestamps-other_system_time1-inf-optimal.txt
│ │ │ │ ├── timestamps-other_timestamp-inf-optimal.txt
│ │ │ │ ├── trace_the_sender-trace_the_sender-inf-dpor.txt
│ │ │ │ ├── transparent_instrumentation-test-inf-dpor.txt
│ │ │ │ ├── trigger_the_after-trigger_the_after-inf-dpor.txt
│ │ │ │ ├── unregister_deadlocked-test1-inf-dpor.txt
│ │ │ │ └── waiting-waiting-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── ac_tab_delete_crash.erl
│ │ │ ├── ac_tab_insert.erl
│ │ │ ├── after_test_2.erl
│ │ │ ├── after_test_3.erl
│ │ │ ├── after_vs_trap_exit.erl
│ │ │ ├── allow_first_crash.erl
│ │ │ ├── application_check.erl
│ │ │ ├── assert_filter.erl
│ │ │ ├── assert_tip.erl
│ │ │ ├── bad_dictionary.erl
│ │ │ ├── bad_whereis.erl
│ │ │ ├── code_when_undef.erl
│ │ │ ├── concuerror_crash.erl
│ │ │ ├── curious_builtins.erl
│ │ │ ├── dead_receive.erl
│ │ │ ├── deeper_exit.erl
│ │ │ ├── demonitor_exhaustive.erl
│ │ │ ├── demonitor_flush.erl
│ │ │ ├── demonitor_sane_opts.erl
│ │ │ ├── depth_bound.erl
│ │ │ ├── erlang_display.erl
│ │ │ ├── erlang_display_string.erl
│ │ │ ├── ets_delete.erl
│ │ │ ├── ets_delete_2.erl
│ │ │ ├── ets_delete_all.erl
│ │ │ ├── ets_delete_object.erl
│ │ │ ├── ets_exceptions.erl
│ │ │ ├── ets_give_away.erl
│ │ │ ├── ets_global_global.erl
│ │ │ ├── ets_heir.erl
│ │ │ ├── ets_heir_2.erl
│ │ │ ├── ets_info.erl
│ │ │ ├── ets_info_details.erl
│ │ │ ├── ets_insert_new.erl
│ │ │ ├── ets_insert_objects.erl
│ │ │ ├── ets_many_insert_new.erl
│ │ │ ├── ets_new.erl
│ │ │ ├── ets_new_failure.erl
│ │ │ ├── ets_new_failure_2.erl
│ │ │ ├── ets_new_failure_3.erl
│ │ │ ├── ets_ref_keys.erl
│ │ │ ├── ets_rename.erl
│ │ │ ├── ets_select.erl
│ │ │ ├── ets_unguarded.erl
│ │ │ ├── ets_unnamed.erl
│ │ │ ├── ets_update_counter.erl
│ │ │ ├── ets_update_element.erl
│ │ │ ├── ets_whereis.erl
│ │ │ ├── exit.erl
│ │ │ ├── exit_kill.erl
│ │ │ ├── exit_message_unpredicted.erl
│ │ │ ├── file_read_file.erl
│ │ │ ├── fun_fail.erl
│ │ │ ├── group_leader.erl
│ │ │ ├── group_leader2.erl
│ │ │ ├── group_leader3.erl
│ │ │ ├── halt_error.erl
│ │ │ ├── halt_support.erl
│ │ │ ├── hibernate.erl
│ │ │ ├── hopeless_after.erl
│ │ │ ├── i_hate_myself.erl
│ │ │ ├── ignore_error_1.erl
│ │ │ ├── ignore_error_2.erl
│ │ │ ├── ignore_error_3.erl
│ │ │ ├── immediate_delivery.erl
│ │ │ ├── infinite_loop.erl
│ │ │ ├── init_race_condition.erl
│ │ │ ├── inspect_system.erl
│ │ │ ├── instr_apply.erl
│ │ │ ├── io_error.erl
│ │ │ ├── io_format.erl
│ │ │ ├── io_format_2.erl
│ │ │ ├── io_format_3.erl
│ │ │ ├── irrelevant_send.erl
│ │ │ ├── is_process_alive_1.erl
│ │ │ ├── keep_going.erl
│ │ │ ├── kill_running_waiting.erl
│ │ │ ├── late_hope.erl
│ │ │ ├── lid_test.erl
│ │ │ ├── link_after.erl
│ │ │ ├── load_before_start.erl
│ │ │ ├── log_all.erl
│ │ │ ├── main_and_backup.erl
│ │ │ ├── many_kill.erl
│ │ │ ├── many_links.erl
│ │ │ ├── many_monitors.erl
│ │ │ ├── many_send_to_dead.erl
│ │ │ ├── many_send_to_dead_2.erl
│ │ │ ├── message_queue_length.erl
│ │ │ ├── messed_deliveries.erl
│ │ │ ├── module_loaded_dep.erl
│ │ │ ├── monitor_demonitor.erl
│ │ │ ├── monitor_failure.erl
│ │ │ ├── monitor_info.erl
│ │ │ ├── monitor_missing_messages.erl
│ │ │ ├── monitor_named.erl
│ │ │ ├── monitor_order.erl
│ │ │ ├── monotonic_time.erl
│ │ │ ├── node_names.erl
│ │ │ ├── nonexistent_module.erl
│ │ │ ├── normal_exit.erl
│ │ │ ├── normal_shutdown.erl
│ │ │ ├── normal_tuple_exit.erl
│ │ │ ├── os_timestamp.erl
│ │ │ ├── pids_are_unsafe.erl
│ │ │ ├── process_flag_link.erl
│ │ │ ├── process_info.erl
│ │ │ ├── processes.erl
│ │ │ ├── processes_leader.erl
│ │ │ ├── racing_after.erl
│ │ │ ├── receive_after.erl
│ │ │ ├── receive_and_after.erl
│ │ │ ├── receive_catchall.erl
│ │ │ ├── receive_exit.erl
│ │ │ ├── receive_loop.erl
│ │ │ ├── receive_with_guard.erl
│ │ │ ├── receive_without_trapping.erl
│ │ │ ├── register_link.erl
│ │ │ ├── registered_1.erl
│ │ │ ├── registered_2.erl
│ │ │ ├── registered_send_1.erl
│ │ │ ├── registered_send_2.erl
│ │ │ ├── registered_send_3.erl
│ │ │ ├── replay_sanity.erl
│ │ │ ├── report_blocks.erl
│ │ │ ├── reuse_raw_pid.erl
│ │ │ ├── safeops_coverage.erl
│ │ │ ├── sched_tests.erl
│ │ │ ├── self_exits.erl
│ │ │ ├── send_after.erl
│ │ │ ├── send_after_trouble.erl
│ │ │ ├── send_named_vs_send.erl
│ │ │ ├── send_receive_dependencies.erl
│ │ │ ├── send_self.erl
│ │ │ ├── send_using_names.erl
│ │ │ ├── send_vs_trap_exit.erl
│ │ │ ├── signals_vs_messages.erl
│ │ │ ├── simple_ets.erl
│ │ │ ├── simple_spawn.erl
│ │ │ ├── sleep_set_block_not_bad.erl
│ │ │ ├── spawn_and_send.erl
│ │ │ ├── spawn_bad.erl
│ │ │ ├── spawn_failure.erl
│ │ │ ├── spawn_monitor_test.erl
│ │ │ ├── spawned_sender_crasher.erl
│ │ │ ├── spawned_senders.erl
│ │ │ ├── stacktrace_vs_exit.erl
│ │ │ ├── system_info.erl
│ │ │ ├── system_instant_delivery.erl
│ │ │ ├── system_non_instant_delivery.erl
│ │ │ ├── timers_afters_exits_crashes.erl
│ │ │ ├── timestamps.erl
│ │ │ ├── trace_the_sender.erl
│ │ │ ├── transparent_instrumentation.erl
│ │ │ ├── trigger_the_after.erl
│ │ │ ├── unregister_deadlocked.erl
│ │ │ ├── unsupported_exit.erl
│ │ │ └── waiting.erl
│ │ ├── bounding_tests/
│ │ │ ├── results/
│ │ │ │ ├── manolis-test_2workers_small-1-bpor-source.txt
│ │ │ │ ├── readers-test-0-dpor.txt
│ │ │ │ ├── readers-test-1-dpor.txt
│ │ │ │ ├── readers-test-2-dpor.txt
│ │ │ │ ├── readers-test-3-dpor.txt
│ │ │ │ ├── readers-test-4-dpor.txt
│ │ │ │ ├── readers-test-5-dpor.txt
│ │ │ │ ├── readers-test-6-dpor.txt
│ │ │ │ ├── readers-test-7-dpor.txt
│ │ │ │ ├── readers_2-test-0-dpor.txt
│ │ │ │ ├── readers_2-test-1-dpor.txt
│ │ │ │ ├── readers_2-test-2-dpor.txt
│ │ │ │ ├── readers_2-test-3-dpor.txt
│ │ │ │ ├── readers_2-test-4-dpor.txt
│ │ │ │ ├── readers_2-test-5-dpor.txt
│ │ │ │ ├── readers_2-test-6-dpor.txt
│ │ │ │ ├── readers_2-test-7-dpor.txt
│ │ │ │ ├── readers_compare-test-0-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-0-bpor-source.txt
│ │ │ │ ├── readers_compare-test-0-optimal.txt
│ │ │ │ ├── readers_compare-test-0-persistent.txt
│ │ │ │ ├── readers_compare-test-0-source.txt
│ │ │ │ ├── readers_compare-test-1-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-1-bpor-source.txt
│ │ │ │ ├── readers_compare-test-1-optimal.txt
│ │ │ │ ├── readers_compare-test-1-persistent.txt
│ │ │ │ ├── readers_compare-test-1-source.txt
│ │ │ │ ├── readers_compare-test-2-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-2-bpor-source.txt
│ │ │ │ ├── readers_compare-test-2-optimal.txt
│ │ │ │ ├── readers_compare-test-2-persistent.txt
│ │ │ │ ├── readers_compare-test-2-source.txt
│ │ │ │ ├── readers_compare-test-6-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-6-bpor-source.txt
│ │ │ │ ├── readers_compare-test-6-optimal.txt
│ │ │ │ ├── readers_compare-test-6-persistent.txt
│ │ │ │ ├── readers_compare-test-6-source.txt
│ │ │ │ ├── readers_delay-test-0-nodpor.txt
│ │ │ │ ├── readers_delay-test-1-nodpor.txt
│ │ │ │ ├── readers_delay-test-2-nodpor.txt
│ │ │ │ ├── readers_delay-test-3-nodpor.txt
│ │ │ │ ├── readers_delay-test-4-nodpor.txt
│ │ │ │ ├── readers_delay-test-5-nodpor.txt
│ │ │ │ ├── readers_delay-test-6-nodpor.txt
│ │ │ │ ├── readers_no_preempt-test-0-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-0-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-0-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-0-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-0-source.txt
│ │ │ │ ├── readers_no_preempt-test-1-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-1-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-1-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-1-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-1-source.txt
│ │ │ │ ├── readers_no_preempt-test-2-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-2-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-2-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-2-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-2-source.txt
│ │ │ │ ├── simple_delay-test-0-dpor.txt
│ │ │ │ ├── simple_delay-test-1-dpor.txt
│ │ │ │ ├── simple_delay-test-2-dpor.txt
│ │ │ │ ├── writers-test-0-dpor.txt
│ │ │ │ ├── writers-test-1-dpor.txt
│ │ │ │ ├── writers-test-2-dpor.txt
│ │ │ │ ├── writers-test-3-dpor.txt
│ │ │ │ ├── writers-test-4-dpor.txt
│ │ │ │ ├── writers-test-5-dpor.txt
│ │ │ │ ├── writers-test-6-dpor.txt
│ │ │ │ └── writers-test-7-dpor.txt
│ │ │ └── src/
│ │ │ ├── manolis/
│ │ │ │ ├── rush_hour.erl
│ │ │ │ ├── search.erl
│ │ │ │ └── test.erl
│ │ │ ├── readers.erl
│ │ │ ├── readers_2.erl
│ │ │ ├── readers_compare.erl
│ │ │ ├── readers_delay.erl
│ │ │ ├── readers_no_preempt.erl
│ │ │ ├── simple_delay.erl
│ │ │ └── writers.erl
│ │ ├── corner_tests/
│ │ │ ├── results/
│ │ │ │ └── deliver_exhaustive-test-inf-nodpor.txt
│ │ │ └── src/
│ │ │ └── deliver_exhaustive.erl
│ │ ├── dpor_tests/
│ │ │ ├── results/
│ │ │ │ ├── POPL_optimal_example-test-inf-dpor.txt
│ │ │ │ ├── POPL_optimal_example-test-inf-source.txt
│ │ │ │ ├── after_test-after_test-inf-dpor.txt
│ │ │ │ ├── after_test_reduced-after_test_reduced-inf-dpor.txt
│ │ │ │ ├── combination_lock_1-combination_lock_1-inf-dpor.txt
│ │ │ │ ├── combination_lock_1-combination_lock_1-inf-source.txt
│ │ │ │ ├── complete_test_1-complete_test_1-inf-dpor.txt
│ │ │ │ ├── complete_test_2-complete_test_2-inf-dpor.txt
│ │ │ │ ├── conditional_readers-conditional_readers-inf-dpor.txt
│ │ │ │ ├── conditional_readers_2-conditional_readers_2-inf-dpor.txt
│ │ │ │ ├── conditional_readers_3-conditional_readers_3-inf-dpor.txt
│ │ │ │ ├── depend_1-depend_1-inf-dpor.txt
│ │ │ │ ├── depend_2-depend_2-inf-dpor.txt
│ │ │ │ ├── depend_3-depend_3-inf-dpor.txt
│ │ │ │ ├── depend_4-depend_4-inf-dpor.txt
│ │ │ │ ├── depend_4_screen-depend_4_screen-inf-dpor.txt
│ │ │ │ ├── depend_5-depend_5-inf-dpor.txt
│ │ │ │ ├── depend_6-depend_6-inf-dpor.txt
│ │ │ │ ├── depend_6_newest-test-inf-dpor.txt
│ │ │ │ ├── depend_6_round-test-inf-dpor.txt
│ │ │ │ ├── diff_dep_1-diff_dep_1-inf-dpor.txt
│ │ │ │ ├── diff_dep_2-diff_dep_2-inf-dpor.txt
│ │ │ │ ├── diff_dep_3-diff_dep_3-inf-dpor.txt
│ │ │ │ ├── diff_obs-test-inf-optimal.txt
│ │ │ │ ├── difficult_readers-difficult_readers-inf-dpor.txt
│ │ │ │ ├── ets_cross-test-inf-dpor.txt
│ │ │ │ ├── ets_dependencies-ets_dependencies-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_2-ets_dependencies_2-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_3-ets_dependencies_3-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_deeper-ets_dependencies_deeper-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_deeper_2-ets_dependencies_deeper_2-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_n-ets_dependencies_n-inf-dpor.txt
│ │ │ │ ├── ets_writing_same-ets_writing_same-inf-dpor.txt
│ │ │ │ ├── etsi-etsi-inf-dpor.txt
│ │ │ │ ├── etsi_2-etsi_2-inf-dpor.txt
│ │ │ │ ├── etsi_3-etsi_3-inf-dpor.txt
│ │ │ │ ├── etsi_4-etsi_4-inf-dpor.txt
│ │ │ │ ├── etsi_5-etsi_5-inf-dpor.txt
│ │ │ │ ├── etsi_6-etsi_6-inf-dpor.txt
│ │ │ │ ├── etsi_7-etsi_7-inf-dpor.txt
│ │ │ │ ├── etsi_8-etsi_8-inf-dpor.txt
│ │ │ │ ├── file_system_example-test-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_1-hairbrush_teeth_1-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_2-hairbrush_teeth_2-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_3-hairbrush_teeth_3-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_4-hairbrush_teeth_4-inf-dpor.txt
│ │ │ │ ├── independent_receivers-independent_receivers-inf-dpor.txt
│ │ │ │ ├── indifferent_senders-indifferent_senders-inf-dpor.txt
│ │ │ │ ├── last_zero-test-inf-dpor.txt
│ │ │ │ ├── last_zero-test-inf-source.txt
│ │ │ │ ├── long_chain-long_chain-inf-dpor.txt
│ │ │ │ ├── many_initials-many_initials-inf-dpor.txt
│ │ │ │ ├── many_kill_2-test-inf-dpor.txt
│ │ │ │ ├── manywrite-manywrite-inf-dpor.txt
│ │ │ │ ├── manywrite_2-manywrite_2-inf-dpor.txt
│ │ │ │ ├── messages_1-messages_1-inf-dpor.txt
│ │ │ │ ├── messages_2-test-inf-dpor.txt
│ │ │ │ ├── no_observers-test-inf-optimal.txt
│ │ │ │ ├── not_prerequisite_1-not_prerequisite_1-inf-dpor.txt
│ │ │ │ ├── observable_others-dep_obs-inf-optimal.txt
│ │ │ │ ├── observable_others-dep_unobs-inf-optimal.txt
│ │ │ │ ├── observable_others-indep_obs-inf-optimal.txt
│ │ │ │ ├── observable_others-indep_unobs-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_empty-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_flush-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_flush_info-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_info-inf-optimal.txt
│ │ │ │ ├── priorities-priorities-inf-dpor.txt
│ │ │ │ ├── process_info-links-inf-optimal.txt
│ │ │ │ ├── proxy-proxy-inf-dpor.txt
│ │ │ │ ├── proxy2-proxy2-inf-dpor.txt
│ │ │ │ ├── readers-test-inf-optimal.txt
│ │ │ │ ├── readers-test-inf-persistent.txt
│ │ │ │ ├── readers-test-inf-source.txt
│ │ │ │ ├── readers_basic-readers_basic-inf-dpor.txt
│ │ │ │ ├── readers_rrw-readers_rrw-inf-dpor.txt
│ │ │ │ ├── readers_rwr-readers_rwr-inf-dpor.txt
│ │ │ │ ├── readers_wrr-readers_wrr-inf-dpor.txt
│ │ │ │ ├── receive_order-test1-inf-dpor.txt
│ │ │ │ ├── receive_order-test2-inf-dpor.txt
│ │ │ │ ├── receive_order-test3-inf-dpor.txt
│ │ │ │ ├── register_again-register_again-inf-dpor.txt
│ │ │ │ ├── register_again_2-register_again_2-inf-dpor.txt
│ │ │ │ ├── same_messages-same_messages-inf-dpor.txt
│ │ │ │ ├── same_messages_2-same_messages_2-inf-dpor.txt
│ │ │ │ ├── same_messages_3-same_messages_3-inf-dpor.txt
│ │ │ │ ├── same_messages_4-same_messages_4-inf-dpor.txt
│ │ │ │ ├── send_it_ets-send_it_ets-inf-dpor.txt
│ │ │ │ ├── sleeping_races_1-sleeping_races_1-inf-dpor.txt
│ │ │ │ ├── sleeping_races_2-sleeping_races_2-inf-dpor.txt
│ │ │ │ ├── sleeping_races_3_read-sleeping_races_3_read-inf-dpor.txt
│ │ │ │ ├── sleeping_races_3_write-sleeping_races_3_write-inf-dpor.txt
│ │ │ │ ├── sleeping_races_4-sleeping_races_4-inf-dpor.txt
│ │ │ │ ├── sleeping_races_5-sleeping_races_5-inf-dpor.txt
│ │ │ │ ├── sleeping_races_6-sleeping_races_6-inf-dpor.txt
│ │ │ │ ├── sleeping_races_6-sleeping_races_6-inf-source.txt
│ │ │ │ ├── sleeping_races_7-sleeping_races_7-inf-dpor.txt
│ │ │ │ ├── sleeping_races_8-sleeping_races_8-inf-dpor.txt
│ │ │ │ ├── stress-stress-inf-dpor.txt
│ │ │ │ ├── sync_start-sync_start-inf-dpor.txt
│ │ │ │ ├── test_after_spawns-test_after_spawns-inf-dpor.txt
│ │ │ │ ├── timer_replayed-test-inf-dpor.txt
│ │ │ │ ├── tricky_predecessors-tricky_predecessors-inf-dpor.txt
│ │ │ │ ├── two_writers_readers_1-two_writers_readers_1-inf-dpor.txt
│ │ │ │ ├── two_writers_readers_2-two_writers_readers_2-inf-dpor.txt
│ │ │ │ ├── wakeup_many-wakeup_many-inf-dpor.txt
│ │ │ │ ├── workers-workers-inf-dpor.txt
│ │ │ │ ├── workers_2-workers_2-inf-dpor.txt
│ │ │ │ └── writeread-writeread-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── POPL_optimal_example.erl
│ │ │ ├── after_test.erl
│ │ │ ├── after_test_reduced.erl
│ │ │ ├── combination_lock_1.erl
│ │ │ ├── complete_test_1.erl
│ │ │ ├── complete_test_2.erl
│ │ │ ├── conditional_readers.erl
│ │ │ ├── conditional_readers_2.erl
│ │ │ ├── conditional_readers_3.erl
│ │ │ ├── depend_1.erl
│ │ │ ├── depend_2.erl
│ │ │ ├── depend_3.erl
│ │ │ ├── depend_4.erl
│ │ │ ├── depend_4_screen.erl
│ │ │ ├── depend_5.erl
│ │ │ ├── depend_6.erl
│ │ │ ├── depend_6_newest.erl
│ │ │ ├── depend_6_round.erl
│ │ │ ├── diff_dep_1.erl
│ │ │ ├── diff_dep_2.erl
│ │ │ ├── diff_dep_3.erl
│ │ │ ├── diff_obs.erl
│ │ │ ├── difficult_readers.erl
│ │ │ ├── ets_cross.erl
│ │ │ ├── ets_dependencies.erl
│ │ │ ├── ets_dependencies_2.erl
│ │ │ ├── ets_dependencies_3.erl
│ │ │ ├── ets_dependencies_deeper.erl
│ │ │ ├── ets_dependencies_deeper_2.erl
│ │ │ ├── ets_dependencies_n.erl
│ │ │ ├── ets_writing_same.erl
│ │ │ ├── etsi.erl
│ │ │ ├── etsi_2.erl
│ │ │ ├── etsi_3.erl
│ │ │ ├── etsi_4.erl
│ │ │ ├── etsi_5.erl
│ │ │ ├── etsi_6.erl
│ │ │ ├── etsi_7.erl
│ │ │ ├── etsi_8.erl
│ │ │ ├── file_system_example.erl
│ │ │ ├── hairbrush_teeth_1.erl
│ │ │ ├── hairbrush_teeth_2.erl
│ │ │ ├── hairbrush_teeth_3.erl
│ │ │ ├── hairbrush_teeth_4.erl
│ │ │ ├── independent_receivers.erl
│ │ │ ├── indifferent_senders.erl
│ │ │ ├── last_zero.erl
│ │ │ ├── long_chain.erl
│ │ │ ├── many_initials.erl
│ │ │ ├── many_kill_2.erl
│ │ │ ├── manywrite.erl
│ │ │ ├── manywrite_2.erl
│ │ │ ├── messages_1.erl
│ │ │ ├── messages_2.erl
│ │ │ ├── no_observers.erl
│ │ │ ├── not_prerequisite_1.erl
│ │ │ ├── observable_others.erl
│ │ │ ├── precise_demonitor.erl
│ │ │ ├── priorities.erl
│ │ │ ├── process_info.erl
│ │ │ ├── proxy.erl
│ │ │ ├── proxy2.erl
│ │ │ ├── readers.erl
│ │ │ ├── readers_basic.erl
│ │ │ ├── readers_rrw.erl
│ │ │ ├── readers_rwr.erl
│ │ │ ├── readers_wrr.erl
│ │ │ ├── receive_order.erl
│ │ │ ├── register_again.erl
│ │ │ ├── register_again_2.erl
│ │ │ ├── same_messages.erl
│ │ │ ├── same_messages_2.erl
│ │ │ ├── same_messages_3.erl
│ │ │ ├── same_messages_4.erl
│ │ │ ├── send_it_ets.erl
│ │ │ ├── sleeping_races_1.erl
│ │ │ ├── sleeping_races_2.erl
│ │ │ ├── sleeping_races_3_read.erl
│ │ │ ├── sleeping_races_3_write.erl
│ │ │ ├── sleeping_races_4.erl
│ │ │ ├── sleeping_races_5.erl
│ │ │ ├── sleeping_races_6.erl
│ │ │ ├── sleeping_races_7.erl
│ │ │ ├── sleeping_races_8.erl
│ │ │ ├── stress.erl
│ │ │ ├── sync_start.erl
│ │ │ ├── test_after_spawns.erl
│ │ │ ├── timer_replayed.erl
│ │ │ ├── tricky_predecessors.erl
│ │ │ ├── two_writers_readers_1.erl
│ │ │ ├── two_writers_readers_2.erl
│ │ │ ├── wakeup_many.erl
│ │ │ ├── workers.erl
│ │ │ ├── workers_2.erl
│ │ │ └── writeread.erl
│ │ └── erlang_tests/
│ │ ├── results/
│ │ │ ├── erlang_maps-maps_fold-inf-optimal.txt
│ │ │ ├── erlang_timer-cancel_bad-inf-optimal.txt
│ │ │ ├── erlang_timer-cancel_badarg-inf-optimal.txt
│ │ │ ├── erlang_timer-read_bad-inf-optimal.txt
│ │ │ └── erlang_timer-read_badarg-inf-optimal.txt
│ │ └── src/
│ │ ├── erlang_maps.erl
│ │ └── erlang_timer.erl
│ ├── test_template.erl
│ └── test_template_stripped.erl
└── tests-real/
├── Makefile
├── README.md
└── suites/
├── check_version.escript
├── erlang-litmus/
│ ├── .gitignore
│ ├── Makefile
│ ├── run_litmus.escript
│ └── test
├── makefile/
│ ├── Makefile
│ └── makefile-tests
├── options/
│ ├── .gitignore
│ ├── Makefile
│ ├── autocomplete/
│ │ ├── autocomplete.sh
│ │ ├── autocomplete_common.erl
│ │ ├── autocomplete_help.erl
│ │ ├── autocomplete_long.erl
│ │ └── autocomplete_short.erl
│ ├── autocomplete-tests
│ ├── footer
│ ├── header
│ ├── option1-tests
│ ├── option2-tests
│ ├── option3-tests
│ ├── other-tests
│ └── src/
│ ├── bad.erl
│ ├── bad_attribute.erl
│ ├── bad_attribute_1.erl
│ ├── bad_attribute_2.erl
│ ├── bad_attribute_3.erl
│ ├── bad_attribute_4.erl
│ ├── bad_attribute_5.erl
│ ├── debug_works.erl
│ ├── eunit_sample.erl
│ ├── excluded.erl
│ ├── excluding.erl
│ ├── first_and_other_deadlock.erl
│ ├── foo.erl
│ ├── from_shell.erl
│ ├── load_nif.erl
│ ├── other_deadlock.erl
│ └── six.erl
├── output/
│ ├── Makefile
│ ├── output-tests
│ ├── ref/
│ │ └── graph.dot
│ └── src/
│ ├── a_fun.erl
│ ├── buggy.erl
│ ├── deadlock.erl
│ ├── fig3.1-ext.erl
│ ├── harmless_exit.erl
│ ├── many_scheds.erl
│ ├── more_stacktrace.erl
│ ├── race_info.erl
│ ├── register.erl
│ └── stacktrace.erl
└── print_colors
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
# EditorConfig is awesome: https://EditorConfig.org
# top-most EditorConfig file
root = true
# Unix-style newlines with a newline ending every file
[*]
end_of_line = lf
insert_final_newline = true
indent_style = space
indent_size = 2
# Tab indentation
[Makefile]
indent_style = tab
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Create a directory containing the following files and change into it: '...'
2. Run Concuerror in the following way: '...'
**Expected behavior**
A clear and concise description of what you expected to happen.
**Environment (please complete the following information):**
- OS: [e.g. Debian]
- Concuerror Version: [retrieve by `concuerror --version`]
**Additional context**
Add any other context about the problem here.
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
================================================
FILE: .github/ISSUE_TEMPLATE/other-issue.md
================================================
---
name: Other Issue
about: An issue that is not a bug report or feature request
---
Please think about the following before opening an Issue (click `Preview` above to read this more easily):
* If you need help using Concuerror, visit the [website][website] for tutorials and general info.
* If you have a question, read [the relevant section in the CONTRIBUTING guide][guide ask] first.
* If you want to report a bug, read [the relevant section in the CONTRIBUTING guide][guide report a bug] first.
* If you want to suggest a feature, read [the relevant section in the CONTRIBUTING guide][guide suggest feature] first.
<!-- Links -->
[guide ask]: /parapluu/Concuerror/blob/master/CONTRIBUTING.md#i-want-to-ask-a-question
[guide report a bug]: /parapluu/Concuerror/blob/master/CONTRIBUTING.md#i-want-to-report-a-bug
[guide suggest feature]: /parapluu/Concuerror/blob/master/CONTRIBUTING.md#i-want-to-suggest-a-feature
[website]: http://parapluu.github.io/Concuerror
================================================
FILE: .github/codecov.yml
================================================
codecov:
notify:
after_n_builds: 4
comment:
after_n_builds: 4
coverage:
status:
project:
default:
target: 94%
patch:
default:
target: 90%
fixes:
- "_build/default/lib/concuerror/::"
================================================
FILE: .github/pull_request_template.md
================================================
## Summary
Describe what will be improved after merging this Pull Request.
## Checklist
* [ ] Has tests (or doesn't need them)
* [ ] Updates CHANGELOG (or too minor)
* [ ] References related Issues
================================================
FILE: .github/scripts/covertool_combine
================================================
#!/usr/bin/env bash
set -euo pipefail
EBIN=$(rebar3 path --ebin --app concuerror)
cd cover
export COVER_COMBINE=all.coverdata
./cover-report data || true
covertool/covertool -cover $COVER_COMBINE -ebin $EBIN -appname concuerror
cd ..
================================================
FILE: .github/scripts/covertool_setup
================================================
#!/usr/bin/env bash
set -euo pipefail
make cover/data
cd cover
git clone https://github.com/covertool/covertool.git --branch 2.0.3
cd covertool
make compile
================================================
FILE: .github/workflows/tests.yml
================================================
name: Tests
on:
push:
branches: master
pull_request:
branches: master
paths-ignore:
- 'docs/**'
schedule:
# Run at 00:00 UTC on the first day of each month
- cron: '00 00 1 * *'
env:
THREADS: 2
jobs:
basic:
runs-on: ubuntu-latest
strategy:
matrix:
target:
- lint
- dialyzer
container: erlang:23
name: ${{ matrix.target }}
steps:
- uses: actions/checkout@v4
- uses: actions/cache@v4
with:
path: '~/.cache'
key: ${{ runner.os }}-rebar-${{ matrix.target }}-${{ hashFiles(format('{0}{1}', github.workspace, '/rebar.config')) }}
restore-keys: |
${{ runner.os }}-rebar-${{ matrix.target }}-
${{ runner.os }}-rebar-
- run: make ${{ matrix.target }}
doc:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: ruby/setup-ruby@v1
with:
ruby-version: 2.7
bundler-cache: true
working-directory: doc
- uses: erlef/setup-beam@v1
with:
otp-version: '24'
rebar3-version: 3.23.0
- run: make -C doc test
tests-latest:
runs-on: ubuntu-latest
strategy:
matrix:
otp:
# Two latest minor versions of the most recent OTP release,
# if supported.
# When a new major OTP release is enabled, also update the badge in
# README.md and the argument given to generate_version_hrl in
# rebar.config
- '23'
target:
- 'tests-unit'
- 'tests-1'
- 'tests-2'
- 'tests-real'
container: erlang:${{ matrix.otp }}
name: OTP ${{ matrix.otp }} - ${{ matrix.target }}
steps:
- uses: actions/checkout@v4
- if: matrix.target != 'tests-unit'
run: .github/scripts/covertool_setup
- run: make ${{ matrix.target }}
env:
CONCUERROR: ${{ github.workspace }}/priv/concuerror
CONCUERROR_COVER: ${{ github.workspace}}/cover/data
- if: matrix.target == 'tests-unit'
run: |
rebar3 covertool generate
cp _build/test/covertool/concuerror.covertool.xml coverage.xml
- if: matrix.target != 'tests-unit'
run: |
.github/scripts/covertool_combine
cp cover/coverage.xml coverage.xml
- uses: codecov/codecov-action@v3
with:
file: coverage.xml
flags: ${{ matrix.target }}
tests-older:
runs-on: ubuntu-latest
strategy:
matrix:
# Last minor version of older OTP releases
otp:
- '22'
- '21'
- '20'
target:
- 'tests-1'
- 'tests-2'
- 'tests-real'
container: erlang:${{ matrix.otp }}
name: OTP ${{ matrix.otp }} - ${{ matrix.target }}
steps:
- uses: actions/checkout@v4
- run: make ${{ matrix.target }}
================================================
FILE: .github/workflows/website.yml
================================================
name: Website
on:
push:
branches: master
paths: 'docs/**'
pull_request:
branches: master
paths: 'docs/**'
schedule:
# Run at 00:00 UTC on the first day of each month
- cron: '00 00 1 * *'
jobs:
test:
strategy:
matrix:
target:
- test
- test-external
name: ${{ matrix.target }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: ruby/setup-ruby@v1
with:
ruby-version: 3.2
bundler-cache: true
working-directory: docs
- run: make -C docs ${{ matrix.target }}
================================================
FILE: .gitignore
================================================
# NOTE! Please use 'git ls-files -i --exclude-standard'
# command after changing this file, to see if there are
# any tracked files which get ignored after the change.
_build
*.beam
concuerror_report.txt
erl_crash.dump
thediff
rebar3
================================================
FILE: CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
## [Unreleased](https://github.com/parapluu/Concuerror/tree/master)
### Added
### Removed
### Changed
- moved from Travis to Github Actions
### Fixed
## [0.21.0](https://github.com/parapluu/Concuerror/releases/tag/0.21.0) - 2020-10-31
### Added
- bash_completion (#308)
- log_all option (#320)
- support for OTP 23.0 (#311)
### Removed
- support for OTP 16, OTP 17, OTP 18, and OTP 19
### Changed
- handling of demonitors (#281)
- handling of process_info(..., messages) (#283)
### Fixed
- fixed stacktrace information (#276)
## [0.20](https://github.com/parapluu/Concuerror/releases/tag/0.20) - 2018-07-15
### Added
- edoc documentation (#274)
- support for OTP 21.0 (#264)
- style checking by Elvis (#266)
- base infrastructure for EUnit tests (and CT eventually) (#263)
### Changed
- use rebar3 for building (#255)
## [0.19](https://github.com/parapluu/Concuerror/releases/tag/0.19) - 2018-05-21
### Added
- Total state space size and time to completion estimation
- `--first_process_errors_only` option
- Parts of [aronisstav/erlang-concurrency-litmus-tests](https://github.com/aronisstav/erlang-concurrency-litmus-tests) as a testsuite
- [Codecov](https://codecov.io/github/parapluu/Concuerror) code coverage tracking
- [contributor's guide](./CONTRIBUTING.md)
- [Github Pull Request and Issue templates](./.github/)
### Removed
- untested code for 'hijacking' processes (e.g. application_controller (#2))
### Changed
- progress bar format
- symbolic PIDs are now shown as "<symbol/last registered name>"
- report shows mailbox contents when a deadlock is detected
- significantly optimized DPOR implementations
- moved concuerror executable to /bin directory
### Fixed
- handling of stacktraces
- exclude instrumentation time from timeouts
## [0.18](https://github.com/parapluu/Concuerror/releases/tag/0.18) - 2018-02-20
### Added
- `--observers` option as a synonym of `--use_receive_patterns`
- Support for erlang:hibernate/3
- Support for more safe built-in operations
- A Changelog
### Changed
- Completely reworked the implementation of `--use_receive_patterns`
- `--use_receive_patterns` default is now `true`
### Fixed
- Handling of exit_signals sent to self() (#5)
## [0.17](https://github.com/parapluu/Concuerror/releases/tag/0.17) - 2017-10-17
## [0.16](https://github.com/parapluu/Concuerror/releases/tag/0.16) - 2016-10-25
## [0.15](https://github.com/parapluu/Concuerror/releases/tag/0.15) - 2016-08-29
## [0.14](https://github.com/parapluu/Concuerror/releases/tag/0.14) - 2015-06-10
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, 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 both within project spaces and in public spaces
when an individual is representing the project or its community. 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 <info@concuerror.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
================================================
FILE: CONTRIBUTING.md
================================================
# How to contribute to Concuerror
First of all, thank you for taking time to contribute to Concuerror!
If you don't know where to start, here are some ["help wanted"][help wanted] issues.
## I want to ask a question.
Use the [mailing list][mailing list] and take a look at the [FAQ][faq] if you haven't already!
## I want to report a bug.
* Ensure that you can reproduce the bug on the [latest version of the `master` branch][latest].
* Take a moment to check whether the bug has already been reported by searching Github's [Issues][Issues]. If you find a relevant one, leave a comment there.
* If you cannot find an existing relevant Issue, [open a new bug Issue][open a new bug Issue].
## I want to write a patch that fixes a bug.
* Find/write at least one small test that fails without the patch.
* Fork Concuerror's repository and push a new branch for your patch, using a suitably descriptive name.
* Make sure to also commit the tests that need the patch. You can find out how test suites are organized in the README files of the [test][test], [tests][tests] and [tests-real][tests-real] directories.
* Make a [Pull Request][pull request].
## I want to suggest a feature.
* **Take a moment to check whether a similar feature has already been requested** by searching Github's [Issues][Issues]. If you find a relevant Issue, leave a comment there.
* Apart from the main repository, take a look at the Issues page of the developer's own fork: [@aronisstav Issues][aronisstav Issues]
* If you cannot find an existing relevant Issue, [open a new feature Issue][open a new feature Issue].
## Code of Conduct
This project and everyone participating in it is governed by the [Contributor Covenant Code of Conduct][Contributor Covenant Code of Conduct]. By participating, you are expected to uphold this code. Please report unacceptable behavior to info@concuerror.com.
Thanks! :heart:
[@aronisstav](https://github.com/aronisstav)
<!-- Links -->
[aronisstav Issues]: https://github.com/aronisstav/Concuerror/issues
[Contributor Covenant Code of Conduct]: ./CODE_OF_CONDUCT.md
[faq]: http://parapluu.github.io/Concuerror/faq
[help wanted]: https://github.com/parapluu/Concuerror/labels/help%20wanted
[Issues]: https://github.com/parapluu/Concuerror/issues
[latest]: https://github.com/parapluu/Concuerror/
[mailing list]: http://parapluu.github.io/Concuerror/contact
[open a new bug Issue]: https://github.com/parapluu/Concuerror/issues/new?template=issue_template_bug.md&labels=bug
[open a new feature Issue]: https://github.com/parapluu/Concuerror/issues/new?template=issue_template_feature.md&labels=feature
[pull request]: https://github.com/parapluu/Concuerror/compare
[test]: ./test
[tests]: ./tests
[tests-real]: ./tests-real
================================================
FILE: LICENSE
================================================
Copyright (c) 2014-2018, Stavros Aronis (<aronisstav@gmail.com>) and Kostis Sagonas (<kostis@cs.ntua.gr>).
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: Makefile
================================================
###-----------------------------------------------------------------------------
### Application info
###-----------------------------------------------------------------------------
NAME := concuerror
REBAR=$(shell which rebar3 || echo "./rebar3")
.PHONY: default
default bin/$(NAME): $(REBAR)
$(REBAR) escriptize
MAKEFLAGS += --no-builtin-rules
.SUFFIXES:
###-----------------------------------------------------------------------------
### Rebar
###-----------------------------------------------------------------------------
REBAR_URL="https://s3.amazonaws.com/rebar3/rebar3"
./$(REBAR):
curl -o $@ $(REBAR_URL) && chmod +x $@
###-----------------------------------------------------------------------------
### Compile
###-----------------------------------------------------------------------------
.PHONY: dev native pedantic
dev native pedantic: $(REBAR)
$(REBAR) as $@ escriptize
###-----------------------------------------------------------------------------
### Edoc
###-----------------------------------------------------------------------------
.PHONY: edoc
edoc: $(REBAR)
$(REBAR) edoc
###-----------------------------------------------------------------------------
### Lint
###-----------------------------------------------------------------------------
.PHONY: lint
lint: $(REBAR)
$(REBAR) as lint lint
###-----------------------------------------------------------------------------
### Dialyzer
###-----------------------------------------------------------------------------
.PHONY: dialyzer
dialyzer: $(REBAR)
$(REBAR) dialyzer
###-----------------------------------------------------------------------------
### Test
###-----------------------------------------------------------------------------
CONCUERROR?=$(abspath bin/$(NAME))
.PHONY: tests
tests: tests-1 tests-2
.PHONY: tests-1
tests-1: bin/$(NAME)
@$(RM) tests/thediff
@(cd tests; ./runtests.py suites/ba*/src/*)
.PHONY: tests-2
tests-2: bin/$(NAME)
@$(RM) tests/thediff
@(cd tests; ./runtests.py suites/b[^a]*/src/* suites/[^b]*/src/*)
## -j 1: ensure that the outputs of different suites are not interleaved
.PHONY: tests-real
tests-real: bin/$(NAME)
@$(RM) $@/thediff
$(MAKE) -j 1 -C $@ \
TOP_DIR=$(abspath .) \
CONCUERROR=$(CONCUERROR) \
DIFFER=$(abspath tests/differ) \
DIFFPRINTER=$(abspath $@/thediff)
.PHONY: tests-unit
tests-unit: bin/$(NAME)
$(REBAR) eunit
###-----------------------------------------------------------------------------
### Cover
###-----------------------------------------------------------------------------
.PHONY: cover
cover: cover/data bin/$(NAME)
$(RM) $</*
$(MAKE) tests tests-real \
CONCUERROR=$(abspath priv/concuerror) \
CONCUERROR_COVER=$(abspath cover/data)
cd cover; ./cover-report data
cover/data:
@printf " MKDIR $@\n"
@mkdir -p $@
###-----------------------------------------------------------------------------
### Clean
###-----------------------------------------------------------------------------
.PHONY: clean
clean: $(REBAR)
$(REBAR) clean --all
.PHONY: distclean
distclean:
$(RM) bin/$(NAME)
$(RM) -r _build
$(RM) ./$(REBAR)
.PHONY: cover-clean
cover-clean:
$(RM) -r cover/data
$(RM) cover/*.COVER.html
.PHONY: maintainer-clean
maintainer-clean: distclean cover-clean
================================================
FILE: README.md
================================================
[![Hex Docs][hex badge]][hex]
[![Tests][tests badge]][tests]
[![Codecov][codecov badge]][codecov]
# Concuerror
Concuerror is a stateless model checking tool for Erlang programs. It can be used to systematically test programs for concurrency errors, detect and report errors that only occur on few, specific schedulings or **verify** their absence.
[Visit the website][website] for documentation, examples, tutorials, publications, and many more!
## Supported OTP Releases
[![Erlang Versions][erlang versions badge]][tests]
## How to build
* Compile : `make`
* Build documentation : `make edoc`
* Run the testsuites : `make tests tests-real tests-unit`
* Run Dialyzer : `make dialyzer`
* Run Elvis : `make lint`
* Check code coverage : `make cover`
* Cleanup : `make clean`
The preferred way to start concuerror is via the `bin/concuerror` escript.
## Is there bash_completion?
[Yes!][bash_completion]
## Is there a changelog?
[Yes!][changelog]
## How to prepare for a release?
[Read this][release]
## Copyright and License
Copyright (c) 2014-2023,
Stavros Aronis (<aronisstav@gmail.com>) and
Kostis Sagonas (<kostis@cs.ntua.gr>).
All rights reserved
Copyright (c) 2011-2013,
Alkis Gotovos (<el3ctrologos@hotmail.com>),
Maria Christakis (<mchrista@softlab.ntua.gr>) and
Kostis Sagonas (<kostis@cs.ntua.gr>).
All rights reserved.
Concuerror is distributed under the Simplified BSD License.
Details can be found in the [LICENSE][license] file.
<!-- Links -->
[bash_completion]: ./resources/bash_completion/concuerror
[changelog]: ./CHANGELOG.md
[codecov]: https://codecov.io/gh/parapluu/Concuerror
[hex]: https://hexdocs.pm/concuerror/
[license]: ./LICENSE
[release]: ./resources/how-to-release.md
[tests]: https://github.com/parapluu/Concuerror/actions/workflows/tests.yml
[website]: http://parapluu.github.io/Concuerror
<!-- Badges -->
[codecov badge]: https://codecov.io/gh/parapluu/Concuerror/branch/master/graph/badge.svg
[erlang versions badge]: https://img.shields.io/badge/erlang-20.3%20to%2023.3-blue.svg
[hex badge]: https://img.shields.io/badge/hex-docs-green.svg
[tests badge]: https://github.com/parapluu/Concuerror/actions/workflows/tests.yml/badge.svg
================================================
FILE: bin/.gitignore
================================================
concuerror
================================================
FILE: cover/.gitignore
================================================
*.coverdata
*.COVER.html
covertool
data
================================================
FILE: cover/cover-report
================================================
#!/usr/bin/env escript
%%! +S1 -nostick -noshell -pa ../_build/default/lib/concuerror/ebin
main([CoverDir]) ->
{ok, Files} = file:list_dir(CoverDir),
Full = [filename:join([CoverDir,F]) || F <- Files],
Foreach = fun(F) -> cover:import(F) end,
lists:foreach(Foreach, Full),
case is_run_to_combine() of
false ->
Foreach2 = fun(M) -> cover:analyse_to_file(M, [html]) end,
lists:foreach(Foreach2, cover:imported_modules());
{true, OutputFile} ->
cover:export(OutputFile)
end,
{result, Result, _} = cover:analyse(coverage, module),
print(Result).
print(List) ->
%% THRESHOLDS
ThresholdSingle = 0.85,
Threshold = 0.94,
%% HEADER
to_stderr("~-30s | ~5s | ~6s | ~5s~n", ["Module", "Lines", "NotCov", "Cov %"]),
print_separator(),
AddPointerSuffix =
fun(true) -> " <--";
(false) -> ""
end,
Fold =
fun({Mod, {Cov, NotCov}}, {Fail, TotSum, CovSum}) ->
Tot = Cov + NotCov,
Pct = Cov / Tot,
Fails = Pct < ThresholdSingle,
%% PER MODULE ENTRY
to_stderr(
"~-30s | ~5w | ~6w | ~5.1f~s~n",
[Mod, Tot, NotCov, Pct * 100, AddPointerSuffix(Fails)]),
{Fail orelse Fails, TotSum + Tot, CovSum + Cov}
end,
{Fail, TotSum, CovSum} = lists:foldl(Fold, {false, 0,0}, List),
Pct = CovSum / TotSum,
TotalFail = Pct < Threshold,
%% FOOTER
print_separator(),
to_stderr("~-30s ~5w ~6w ~5.1f~s~n",
["Total", TotSum, CovSum, Pct * 100, AddPointerSuffix(TotalFail)]),
case Fail of
false -> ok;
true ->
to_stderr(
"~nFail: Code coverage for some module(s) is below ~.1f% threshold!~n",
[ThresholdSingle * 100])
end,
case TotalFail of
false -> ok;
true ->
to_stderr(
"~nFail: Total code coverage is below ~.1f% threshold!~n",
[Threshold * 100])
end,
case Fail orelse TotalFail of
true -> halt(1);
false -> halt(0)
end.
print_separator() ->
to_stderr("~s~n", [[$- || _ <- lists:seq(1, 55)]]).
to_stderr(Format, Args) ->
io:format(standard_error, Format, Args).
is_run_to_combine() ->
case os:getenv("COVER_COMBINE") of
false -> false;
OutputFile -> {true, OutputFile}
end.
================================================
FILE: doc/.gitignore
================================================
*_option.edoc
*.css
*.html
edoc-info
erlang.png
Gemfile.lock
================================================
FILE: doc/Gemfile
================================================
source 'https://rubygems.org'
gem "html-proofer"
================================================
FILE: doc/Makefile
================================================
.PHONY: default
default: build
Gemfile.lock: Gemfile
bundle install
touch $@
.PHONY: build
build:
make -C .. edoc
.PHONY: test
test: build Gemfile.lock
bundle exec htmlproofer --disable-external=true --ignore-files "/vendor/" --log_level=debug --allow_missing_href=true --enforce_https=false .
.PHONY: clean
clean:
$(RM) *_option.edoc *.html *.css erlang.png edoc-info Gemfile.lock
================================================
FILE: doc/overview.edoc
================================================
@title Concuerror's API specification
@doc
== Welcome! ==
This documentation contains Concuerror's API specification. It is
complementary to the user guides and tutorials available at
[https://parapluu.github.io/Concuerror]. Please start there if you
are looking for general information about what the tool can do and how
it works.
== Table of Contents ==
<ul>
<li>{@section Invoking Concuerror}</li>
<li>{@section Help}</li>
<li>{@section Options}</li>
<li>{@section Standard Error Printout}</li>
<li>{@section Report File}</li>
<li>{@section Graph Output}</li>
</ul>
== Invoking Concuerror ==
The recommended method to invoke Concuerror is via the `bin/concuerror'
escript (available after running `make').
See the documentation of the {@link concuerror} module for more
information about the entry points and return values.
== Options ==
Concuerror is configured using a number of options.
See the documentation of the {@link concuerror_options} module.
== Help ==
The {@link concuerror_options:help_option/0. `help'} option can be
used to access help.
== Standard Error Printout ==
By default, Concuerror prints diagnostic messages in the standard
error stream.
See the documentation of the {@link
concuerror_options:verbosity_option/0. `verbosity'} option.
== Report File ==
By default, Concuerror prints analysis findings in a report file.
See the documentation of the {@link
concuerror_options:output_option/0. `output'} option.
== Graph Output ==
Optionally, Concuerror can produce a graphical representation of the
exploration tree, by combining the explored interleavings.
See the documentation of the {@link
concuerror_options:graph_option/0. `graph'} option.
================================================
FILE: docs/.bundle/config
================================================
---
BUNDLE_PATH: "vendor/bundle"
================================================
FILE: docs/.gitignore
================================================
/_site
.jekyll-cache
vendor
================================================
FILE: docs/404.md
================================================
---
layout: search
title: "Page Not Found"
description: "Page not found"
---
## 404 Error
Sorry, but the page you were trying to view does not exist.
Search the site:
================================================
FILE: docs/CNAME
================================================
concuerror.com
================================================
FILE: docs/Gemfile
================================================
source 'https://rubygems.org'
gem "github-pages", group: :jekyll_plugins
gem "html-proofer"
gem "webrick"
================================================
FILE: docs/Makefile
================================================
.PHONY: default
default: build
JEKYLL = bundle exec jekyll
PROOFER = bundle exec htmlproofer ./_site --checks "Images,Links,Script,Favicon,OpenGraph"
.PHONY: jekyll
jekyll: Gemfile
bundle install
.PHONY: build
build: jekyll
$(JEKYLL) build
.PHONY: serve
serve: jekyll
$(JEKYLL) serve --config _config.yml,_config_local.yml
.PHONY: test
test: build
$(PROOFER) --disable_external
.PHONY: test-external
test-external: build
$(PROOFER) --ignore-status-codes "302,403"
================================================
FILE: docs/README.md
================================================
# Concuerror's Website
Based on the [**So Simple Theme**](http://mmistakes.github.io)
## How to build
`bundle install`
`jekyll serve`
================================================
FILE: docs/_config.yml
================================================
# Base config
title: "Concuerror"
description: "Concuerror is a model checking tool for debugging, testing and verifying concurrent Erlang programs."
logo: "/images/site-logo.png"
url: "https://concuerror.com"
# Owner/author information
author: stavros
# Theme
remote_theme: "aronisstav/so-simple-theme@b968090"
skin: "/assets/css/skins/default.css"
locale: en-US
date_format: "%B %-d, %Y"
# Front Matter Defaults
defaults:
# Posts defaults
- scope:
path: "_posts"
type: posts
values:
layout: post
share: true
read_time: true
words_per_minute: 50
# Search
search_full_content: true
# Taxonomy pages
category_archive_path: /
# Fonts
google_fonts:
- name: "Source Sans Pro"
weights: "400,400i,700,700i"
- name: "Lora"
weights: "400,400i,700,700i"
# Footer Links
footer_links:
- title: Home
url: /
icon: fas fa-home
- title: Github
url: https://github.com/parapluu/Concuerror
icon: fab fa-github
- title: Github Stars
url: https://github.com/parapluu/Concuerror/stargazers
icon: fas fa-star
- title: Feed
url: feed.xml
icon: fas fa-rss-square
# Liquid
liquid:
error_mode: strict
# https://github.com/mojombo/jekyll/wiki/Permalinks
permalink: /:categories/:title:output_ext
# Markdown
markdown: kramdown
kramdown:
auto_ids: true
footnote_nr: 1
entity_output: as_char
syntax_highlighter: rouge
toc_levels: 1..6
# Plugins
plugins:
- jekyll-feed
- jekyll-gist
- jekyll-redirect-from
- jekyll-seo-tag
# Feed
feed:
path: "feed.xml"
# Redirects
redirect_from:
json: false
# Include/exclude
include: [".htaccess"]
exclude: ["CNAME", "Gemfile", "Gemfile.lock", "Makefile", "README.md", "vendor"]
================================================
FILE: docs/_config_local.yml
================================================
url: ""
================================================
FILE: docs/_data/authors.yml
================================================
stavros:
name: Stavros Aronis
picture: https://www.gravatar.com/avatar/5730e85681def67cb10151437519f39d?s=200
email: aronisstav@gmail.com
twitter: "@Vahnatai"
links:
- title: Twitter
url: https://twitter.com/Vahnatai
icon: fab fa-twitter-square
- title: Github
url: https://github.com/aronisstav
icon: fab fa-github
================================================
FILE: docs/_data/navigation.yml
================================================
- title: <i class="fas fa-home"></i> Home
url: /
- title: <i class="fas fa-newspaper"></i> News
url: /news
- title: <i class="fas fa-download"></i> Download
url: /download
- title: <i class="fas fa-question-circle"></i> FAQ
url: /faq
- title: <i class="fas fa-info-circle"></i> Tutorials
url: /tutorials
- title: <i class="fas fa-plug"></i> API (Hexdocs)
url: https://hexdocs.pm/concuerror
- title: <i class="fas fa-book"></i> Publications
url: /publications
- title: <i class="fas fa-envelope"></i> Contact
url: /contact
icon: fas fa-envelope
- title: <i class="fas fa-search"></i> Search
url: /search
- title: <i class="fab fa-github"></i> Github
url: https://github.com/parapluu/Concuerror
================================================
FILE: docs/_data/text.yml
================================================
# Theme text and labels
# English (default)
# -----------------
en: &DEFAULT_EN
skip_links: "Skip links"
skip_primary_nav: "Skip to primary navigation"
skip_content: "Skip to content"
skip_footer: "Skip to footer"
menu_label: "Menu"
by: "by"
min_read: "min read"
read_more: "Read more…"
categories: "Categories"
tags: "Tags"
pages_categorized: "Pages filed under"
pages_tagged: "Pages tagged"
table_of_contents: "Table of Contents"
results_found: "Result(s) found"
share: "Share"
tweet: "Tweet"
next: "Next"
previous: "Previous"
newer: "Newer"
older: "Older"
back_to_top: "Back to Top"
search_placeholder_text: "Enter your search term..."
powered_by: "Powered by"
en-US:
<<: *DEFAULT_EN
en-CA:
<<: *DEFAULT_EN
en-GB:
<<: *DEFAULT_EN
en-AU:
<<: *DEFAULT_EN
# German
# -----------------
de: &DEFAULT_DE
skip_links: "Links überspringen"
skip_primary_nav: "Zu Hauptmenü springen"
skip_content: "Zu Inhalt springen"
skip_footer: "Zu Fußzeile springen"
menu_label: "Menü"
by: "von"
min_read: "min read"
read_more: "Mehr lesen…"
categories: "Kategorien"
tags: "Tags"
pages_categorized: "Seiten kategorisiert als"
pages_tagged: "Seiten, getaggt als"
table_of_contents: "Inhaltsverzeichnis"
results_found: "Ergebnis(se) gefunden"
share: "Teilen"
tweet: "Tweet"
next: "Vor"
previous: "Zurück"
newer: "Neuer"
older: "Älter"
back_to_top: "Zurück nach Oben"
search_placeholder_text: "Suchtext eingeben..."
powered_by: "Unterstützt von"
de-DE:
<<: *DEFAULT_DE
de-AU:
<<: *DEFAULT_DE
de-CH:
<<: *DEFAULT_DE
# Spanish
# -------
es: &DEFAULT_ES
skip_links: "Saltar enlaces"
skip_primary_nav: "Saltar a la navegación primaria"
skip_content: "Saltar al contenido"
skip_footer: "Saltar al pie de página"
menu_label: "Menú"
by: "por"
min_read: "minuto(s) de lectura"
read_more: "Leer más…"
categories: "Categorías"
tags: "Etiquetas"
pages_categorized: "Páginas archivadas bajo"
pages_tagged: "Páginas etiquetadas"
table_of_contents: "Tabla de contenidos"
results_found: "Resultado(s) encontrado(s)"
share: "Compartir"
tweet: "Tweet"
next: "Siguiente"
previous: "Anterior"
newer: "Nuevo"
older: "Antiguo"
back_to_top: "Volver arriba"
search_placeholder_text: "Ingrese su término de búsqueda ..."
powered_by: "Energizado por"
es-ES:
<<: *DEFAULT_ES
es-CL:
<<: *DEFAULT_ES
# French
# -----------------
fr: &DEFAULT_FR
skip_links: "Sauter les liens"
skip_primary_nav: "Aller à la navigation principale"
skip_content: "Aller au contenu"
skip_footer: "Aller au pied de page"
menu_label: "Menu"
by: "par"
min_read: "min de lecture"
read_more: "En savoir plus…"
categories: "Catégories"
tags: "Tags"
pages_categorized: "Pages catégorisées dans"
pages_tagged: "Pages étiquettées"
table_of_contents: "Table des matières"
results_found: "Résultat(s) trouvé(s)"
share: "Partager"
tweet: "Tweet"
next: "Suivant"
previous: "Précédent"
newer: "Plus récent"
older: "Plus ancier"
back_to_top: "Retour en haut"
search_placeholder_text: "Entrer le terme à rechercher..."
powered_by: "Propulsé par"
fr-FR:
<<: *DEFAULT_FR
fr-BE:
<<: *DEFAULT_FR
fr-CA:
<<: *DEFAULT_FR
it: &DEFAULT_IT
skip_links: "Salta links"
skip_primary_nav: "Salta alla navigazione primaria"
skip_content: "Vai al contenuto"
skip_footer: "Vai al footer"
menu_label: "Menu"
by: "di"
min_read: "min. per leggere"
read_more: "Leggi di più…"
categories: "Categorie"
tags: "Tags"
pages_categorized: "Pagine categorizzate come"
pages_tagged: "Pagine con tag"
table_of_contents: "Indice dei Contenuti"
results_found: "Risultati della ricerca"
share: "Condividi"
tweet: "Tweet"
next: "Avanti"
previous: "Indietro"
newer: "Nuovi"
older: "Vecchi"
back_to_top: "Torna in cima"
search_placeholder_text: "Inserisci una parola da cercare..."
powered_by: "Generato da"
it-IT:
<<: *DEFAULT_IT
# Turkish
# -----------------
tr: &DEFAULT_TR
skip_links: "Linklere git"
skip_primary_nav: "Birincil navigasyona git"
skip_content: "İçeriğe git"
skip_footer: "Sayfa altbilgisine git"
menu_label: "Menü"
by: "by"
min_read: "dakikalık okuma"
read_more: "Daha fazla…"
categories: "Kategoriler"
tags: "Etiketler"
pages_categorized: "Pages filed under"
pages_tagged: "Pages tagged"
table_of_contents: "Başlıklar"
results_found: "Sonuç bulundu"
share: "Paylaş"
tweet: "Tweet"
next: "Sonraki"
previous: "Önceki"
newer: "Daha Yeni"
older: "Daha Eski"
back_to_top: "Başa Dön"
search_placeholder_text: "Arama teriminizi girin..."
powered_by: "Powered by"
tr-TR:
<<: *DEFAULT_TR
================================================
FILE: docs/_includes/footer-custom.html
================================================
<div class="small">{% if page.updated %}Page last modified on {{ page.updated | date: site.date_format }} | {% endif %}<a href="#primary-nav"> {{ site.data.text[site.locale].back_to_top | default: 'Back to Top' }} ↑</a></div>
<br />
================================================
FILE: docs/_includes/head-custom.html
================================================
<link rel="shortcut icon" href="/images/favicon.ico" type="image/x-icon">
================================================
FILE: docs/_includes/masthead.html
================================================
<header class="masthead">
<div class="wrap">
{% if site.logo %}
<a href="{{ '/' | relative_url }}" class="site-logo" rel="home" title="{{ site.title }}">
<img src="{{ site.logo | relative_url }}" class="animated fadeInDown" alt="{{ site.title }}">
</a>
{% endif %}
{% assign page_image = page.image.path | default: page.image %}
</div>
</header><!-- /.masthead -->
================================================
FILE: docs/_includes/yt.html
================================================
<iframe width="560" height="315" src="https://www.youtube.com/embed/{{ yt-link }}" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
================================================
FILE: docs/_posts/2013-09-03-site.md
================================================
---
layout: post
title: "Concuerror's website"
category: news
redirect_from: /site.html
---
Concuerror just got a website!
================================================
FILE: docs/_posts/2013-09-23-euc-2013.md
================================================
---
layout: post
title: "Tutorial at EUC 2013: Video and Slides"
author: Kostis Sagonas
category: tutorials
---
Kostis Sagonas gave a presentation about Concuerror at the Erlang User Conference 2013.
{% assign yt-link = "FpkjKN9wTKg" %}
{% include yt.html %}
[Get the slides](https://www.erlang-factory.com/upload/presentations/858/euc_pres.pdf).
You can also find the video and slides [here](https://www.erlang-factory.com/conference/ErlangUserConference2013/speakers/KostisSagonas).
================================================
FILE: docs/_posts/2014-06-02-poolboy-example.md
================================================
---
layout: post
title: "Concuerror basics (Testing Poolboy, Part 1)"
category: tutorials
updated: 2018-03-21
---
In this tutorial we will explain some basic use of Concuerror
to analyze a few tests written for the
[Poolboy](https://github.com/devinus/poolboy) library.
{:.no_toc}
Index
-----
1. This text will be replaced by the ToC, excluding the previous header (WOW!)
{:toc}
Setting up Concuerror, Poolboy and our first test
-------------------------------------------------
### Setting up Concuerror
The first step is to download and make Concuerror as described in the [Download](/download) page.
For the rest of the tutorial we will assume that the `concuerror` executable
is in our path. For example, to get help for all of Concuerror's options we just
run:
{% highlight bash %}
$ concuerror -h
Usage: ./concuerror [-m <module>] [-t [<test>]] [-o [<output>]] [-h]
[--version] [--pa <pa>] [--pz <pz>] [-f <file>]
[-v <verbosity>] [-q] [--print_depth [<print_depth>]]
[...]
{% endhighlight %}
### Setting up Poolboy
We will be using version
[`1.2.2`](https://github.com/devinus/poolboy/releases/tag/1.2.2) of Poolboy.
{% highlight bash %}
$ git clone https://github.com/devinus/poolboy.git --branch 1.2.2
[...]
$ cd poolboy
poolboy $ make
==> poolboy (compile)
Compiled src/poolboy_worker.erl
Compiled src/poolboy_sup.erl
Compiled src/poolboy.erl
{% endhighlight %}
We will be using the sample worker used in Poolboy's own tests, so we should
`make` the tests as well:
{% highlight bash %}
poolboy $ make test
[...]
{% endhighlight %}
We don't care about the actual result of the tests, but we now have a
`.eunit` directory with `poolboy_test_worker.beam`.
#### No special compilation needed
Notice that we don't need to compile anything in a special way. Concuerror will
intercept calls to any module that is in Erlang's code path and instrument the
code before our test reaches it.
### Our first test
Concuerror explores all the interleavings of an arbitrary execution scenario of
a program with a single entry point. We will be extracting tests from [Poolboy's
own test
suite](https://github.com/devinus/poolboy/blob/1.2.2/test/poolboy_tests.erl).
Let's begin with an adapted version of the start/stop test, which we save as
[`poolboy_tests_1.erl`](https://gist.github.com/aronisstav/b67df16361cd9a2fa87e#file-poolboy_tests_1-erl):
{% gist aronisstav/b67df16361cd9a2fa87e %}
#### Using `.erl` files
We don't have to compile our test, as Concuerror can also analyze `.erl` files,
which are instrumented and compiled before the test starts.
We are now ready to...
Start testing!
--------------
We now have our application code compiled and ready to go, and have written a
small test. Next, we have to tell Concuerror to compile and load our test file
(using option `-f`) and then start testing from module
`poolboy_tests_1`, calling function `pool_startup`, which must have zero
arity:
{% highlight bash %}
poolboy $ concuerror -f poolboy_tests_1.erl -m poolboy_tests_1 -t pool_startup
{% endhighlight %}
Several lines should be printed on our screen. Let's focus on a few of them:
### The output file
{% highlight text %}
Concuerror started at 02 Jun 2014 09:00:00
Writing results in concuerror_report.txt
{% endhighlight %}
Concuerror mainly produces a textual log, saved by default as
`concuerror_report.txt`. You can specify a different filename with the `-o`
option.
### Info messages
{% highlight text %}
Info: Instrumented poolboy_tests_1
{% endhighlight %}
Log messages tagged as *Info* are standard, normal operation messages.
Here, Concuerror reports that it compiled and instrumented our test file and
started to run the test.
{% highlight text %}
Info: Instrumented io_lib
Info: Instrumented poolboy
Info: Instrumented proplists
Info: Instrumented gen_server
[...]
{% endhighlight %}
Concuerror can detect which modules are being used by the test, and instruments
them automatically. You can see a few of them listed above. `io_lib` is also
included, for reasons that are not important to explain right now.
### Warning messages
{% highlight text %}
Warning: Concuerror does not fully support erlang:get_stacktrace/0 ...
{% endhighlight %}
Log messages tagged as *Warnings* are non-critical, notifying about weak
support for some feature or the use of an option that alters the output
### Tip messages
{% highlight text %}
Tip: An abnormal exit signal was sent to a process...
{% endhighlight %}
Log messages tagged as *Tips* are also non-critical, notifying of a
suggested refactoring or option that can be used to make testing more efficient.
### The interesting bits!
By default, Concuerror will stop exploration on the first error it encounters.
In this particular case, it seems that in the very first interleaving we managed
to trigger some behavior that the tool considers problematic. If we take a look
at the output file `concuerror_report.txt`, we will see something like the
following:
{% highlight text %}
{% raw %}
* At step 49 process P.1 exited abnormally
Reason:
{{badmatch,
{error,
{'EXIT',
{undef,
[{poolboy_test_worker,start_link,
[[{name,{local,poolboy_test}},
{worker_module,poolboy_test_worker},
{size,1},
{max_overflow,...}]],
[]},
{supervisor,do_start_child_i,3,
[{file,"supervisor.erl"},{line,330}]},
{supervisor,handle_call,3,[{file,[...]},{line,...}]},
{gen_server,handle_msg,5,[{file,...},{...}]},
{proc_lib,init_p_do_apply,3,[{...}|...]},
{concuerror_callback,process_top_loop,1,[...]}]}}}},
[{poolboy,new_worker,1,[{file,"src/poolboy.erl"},{line,242}]},
[...]
{% endraw %}
{% endhighlight %}
### Using `-pa` to add directories in Erlang's code path
Whoops! We forgot to add the `poolboy_test_worker` module to Erlang's code
path. Concuerror uses the `--pa` option for this (notice the *two* dashes).
Running it again...
{% highlight bash %}
poolboy $ concuerror -f poolboy_tests_1.erl -m poolboy_tests_1 -t pool_startup \
--pa .eunit
{% endhighlight %}
... yields:
{% highlight text %}
[...]
Tip: A process crashed with reason '{timeout, ...}'. This may happen when a call
to a gen_server (or similar) does not receive a reply within some standard
timeout. Use the '--after_timeout' option to treat after clauses that exceed some
threshold as 'impossible'.
Tip: An abnormal exit signal was sent to a process. This is probably the worst
thing that can happen race-wise, as any other side-effecting operation races
with the arrival of the signal. If the test produces too many interleavings
consider refactoring your code.
Tip: A process crashed with reason 'shutdown'. This may happen when a supervisor
is terminating its children. You can use '--treat_as_normal shutdown' if this is
expected behavior.
Error: Stop testing on first error. (Check '-h keep_going').
[...]
{% endhighlight %}
Three tips and the same error. This time however, `concuerror_report.txt`
contains something like:
{% highlight text %}
{% raw %}
Erroneous interleaving 1:
* At step 52 process P exited abnormally
Reason:
{timeout,{gen_server,call,[P.1,stop]}}
Stacktrace:
[{gen_server,call,2,[{file,"gen_server.erl"},{line,182}]},
{poolboy_tests_1,pool_startup,0,
[{file,"poolboy_tests_1.erl"},{line,8}]}]
* At step 76 process P.1.1.1 exited abnormally
Reason:
shutdown
Stacktrace:
[]
* At step 85 process P.1.1 exited abnormally
Reason:
shutdown
Stacktrace:
[{proc_lib,exit_p,2,[{file,"proc_lib.erl"},{line,260}]}]
{% endraw %}
{% endhighlight %}
This behavior seems to be expected within the context of the test. Find out why
Concuerror reports it as problematic in the next part of this tutorial.
{:.no_toc}
# [<center><font color='green'>Continue to the next part!</font></center>]({% post_url 2014-06-03-poolboy-example-errors %})
================================================
FILE: docs/_posts/2014-06-03-poolboy-example-errors.md
================================================
---
layout: post
title: "Reading Concuerror's reports (Testing Poolboy, Part 2)"
category: tutorials
updated: 2018-03-21
---
We continue our tutorial on Concuerror, explaining the errors it can detect and
the options that you can use to filter out those that are not important for your
application.
Read also the [first part]({% post_url 2014-06-02-poolboy-example %})!
{:.no_toc}
Index
-----
1. This text will be replaced by the ToC, excluding the previous header (WOW!)
{:toc}
Symbolic names
--------------
Concuerror makes an effort to replace every Erlang PID that appears in its
report with a symbolic name. The first process spawned is labelled *P* and
every other process is named after the process that spawned it, with an integer
denoting the order in which it was spawned i.e. *P*'s first "child" is named
*P.1*, *P.1*'s third child is named *P.1.3* and so on.
If you prefer to see the raw PIDs you can use
`--symbolic_names false`. Concuerror is reusing the same processes, so the
results should be consistent across different interleavings.
Abnormal exits
--------------
Every time a process exits abnormally, Concuerror will mark the interleaving as
erroneous. This means that any exception that escapes to the top-level will
trigger a warning. [In our example]({% post_url 2014-06-02-poolboy-example%}/#using--pa-to-add-directories-in-erlangs-code-path),
processes *P*, *P.1.1* and *P.1.1.1* exited abnormally.
{% highlight text %}
{% raw %}
Erroneous interleaving 1:
* At step 52 process P exited abnormally
Reason:
{timeout,{gen_server,call,[P.1,stop]}}
Stacktrace:
[{gen_server,call,2,[{file,"gen_server.erl"},{line,182}]},
{poolboy_tests_1,pool_startup,0,
[{file,"poolboy_tests_1.erl"},{line,8}]}]
* At step 76 process P.1.1.1 exited abnormally
Reason:
shutdown
Stacktrace:
[]
* At step 85 process P.1.1 exited abnormally
Reason:
shutdown
Stacktrace:
[{proc_lib,exit_p,2,[{file,"proc_lib.erl"},{line,260}]}]
{% endraw %}
{% endhighlight %}
### Ignoring "after" timeouts
If we take a look at the trace we can see that *P* triggered the standard
timeout clause of a `gen` call:
{% highlight text %}
50: P: receive timeout expired after 5000 ms
in gen.erl line 213
[...]
52: P: exits abnormally ({timeout,{gen_server,call,[P.1,stop]}})
{% endhighlight %}
As explained
[here](/faq/#how-does-concuerror-handle-timeouts-and-other-time-related-functions),
Concuerror by default assumes that any *receive* statement may trigger the
*after* clause, unless it is impossible for a matching message not to have
already arrived.
However, let's assume that we don't care about such timeouts. We can use the
`--after_timeout 1000` to treat any timeout *higher than 1000ms* as
*infinity*. Notice that the one of the tips we got earlier suggests the same
course of action:
{% highlight text %}
Tip: A process crashed with reason '{timeout, ...}'. This may happen when a call
to a gen_server (or similar) does not receive a reply within some standard
timeout. Use the '--after_timeout' option to treat after clauses that exceed some
threshold as 'impossible'.
{% endhighlight %}
### Treating abnormal exit reasons as normal
The other two processes exited abnormally because they were terminated by events
generated by the delivery of a `stop` message to a supervisor. The supervisor
then sent `shutdown` exit signals to the relevant processes. Again, let's assume
that this is acceptable behaviour in our context, using `--treat_as_normal
shutdown` (also suggested by a tip).
{% highlight text %}
Tip: A process crashed with reason 'shutdown'. This may happen when a supervisor
is terminating its children. You can use '--treat_as_normal shutdown' if this is
expected behavior.
{% endhighlight %}
A report without problems
-------------------------
We now run Concuerror again, using the new options:
{% highlight bash %}
poolboy $ concuerror -f poolboy_tests_1.erl -m poolboy_tests_1 -t pool_startup \
--pa .eunit --after_timeout 1000 --treat_as_normal shutdown
{% endhighlight %}
This time the output finishes in:
{% highlight text %}
[...]
Warning: Some abnormal exit reasons were treated as normal ('--treat_as_normal').
Done! (Exit status: completed)
Summary: 0 errors, ... interleavings explored
{% endhighlight %}
Concuerror finished the exploration, finding all the different states that the
program can reach. None of these interleavings had any processes terminating
abnormally with a reason different from `shutdown`, nor any other errors.
### Interleavings as a graph
Concuerror can also produce a
[DOT](https://en.wikipedia.org/wiki/DOT_(graph_description_language)) file,
including all the interleavings. This feature can be enabled with `--graph <filename>`.
You can then use <a href="https://linux.die.net/man/1/dot" data-proofer-ignore>`dot`</a> to convert
the DOT file to an image.
### Racing events
The report includes a section where each pair of events that are racing is
reported, to justify each additional interleaving. Let's take a look at the
output:
{% highlight text %}
[...]
################################################################################
Race Pairs:
--------------------------------------------------------------------------------
You can disable race pair messages with '--show_races false'
* Exit signal (normal) from P.1 reaches P.1.1
is in race with
Message ({'DOWN',#Ref<0.0.0.508>,process,P.1.1.1,shutdown}) from P.1.1.1 reaches P.1.1
* Message ({'DOWN',#Ref<0.0.0.508>,process,P.1.1.1,shutdown}) from P.1.1.1 reaches P.1.1
is in race with
Timer #Ref<0.0.0.522>: expires, delivering {timeout,#Ref<0.0.0.522>,kill} to P.1.1
* P.1: exits normally
is in race with
P: true = erlang:demonitor(#Ref<0.0.0.407>, [flush])
in gen.erl line 215
{% endhighlight %}
We can see e.g. that the delivery of an exit signal from a linked process races
with the delivery of an arbitrary message, (since `P.1.1` is trapping exits), a
similar race appears between a message from a timer and finally a process
exiting races with the cancellation of a monitor, as the monitor message will be
sent in one case but not in the other.
The same pair of events may be reported multiple times, but this should happen
only if we are exploring the reverse interleaving of a different race.
**If you see a pair of events that you believe should not be racing, feel free
to [report the
discrepancy!](https://github.com/parapluu/Concuerror/issues/new) Concuerror's
race detection accuracy is the most sensitive component regarding the total
number of interleavings explored!**
"Deadlocked" processes
---------------------
Since we called `poolboy:stop/1`, all processes were properly stopped. What
would happen if we had let a process lingering? We already have such a test,
`pool_startup_no_stop/0` (we need to use `poolboy:start/1` instead of
`start_link`, as the normal exit signal from the initial process also causes a
shutdown).
{% gist aronisstav/b67df16361cd9a2fa87e %}
Running this test, yields:
{% highlight bash %}
poolboy $ concuerror -f poolboy_tests_1.erl -m poolboy_tests_1 --pa .eunit \
-t pool_startup_no_stop
Concuerror started at 03 Jun 2014 12:00:00
Writing results in concuerror_report.txt
[...]
Done! (Exit status: warning)
Summary: 1 errors, 1/1 interleavings explored
{% endhighlight %}
The output file now contains the following description:
{% highlight text %}
Erroneous interleaving 1:
* Blocked at a 'receive' ("deadlocked"; other processes have exited):
P.1 in gen_server.erl line 360
P.1.1 in gen_server.erl line 360
P.1.1.1 in gen_server.erl line 360
{% endhighlight %}
Concuerror reports any processes that have not exited, when no other processes
are available to run. Such processes are blocked at a *receive* statement and
are considered "deadlocked". These warnings can be turned off by `--ignore_error
deadlock`.
Concuerror will always reset the test to the initial state, so leaving some
processes running may be a better alternative to suffering from all the races
between exit signals that appear at termination.
================================================
FILE: docs/_posts/2014-08-11-euc-2014.md
================================================
---
layout: post
title: "Talk at EUC 2014: Video and Slides"
updated: 2015-06-17
category: news
redirect_from: /euc-2014.html
---
Stavros Aronis gave a presentation about Concuerror at the Erlang User Conference 2014.
<iframe src="//player.vimeo.com/video/102710173" width="500" height="281" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe> <p><a href="https://vimeo.com/102710173">Stavros Aronis - Concuerror: Into Real Code</a> from <a href="https://vimeo.com/erlang">Erlang Solutions</a> on <a href="https://vimeo.com">Vimeo</a>.</p>
[Get the slides](https://www.erlang-factory.com/static/upload/media/1402329241902242concuerrorintorealcodestavrosaroniseuc14.pdf).
You can also find the video and slides [here](https://www.erlang-factory.com/euc2014/stavros-aronis).
================================================
FILE: docs/_posts/2015-06-10-euc-2015.md
================================================
---
layout: post
title: "Tutorial at EUC 2015: Slides"
category: tutorials
updated: 2015-06-10
---
Stavros Aronis is presenting a tutorial on Concuerror at the Erlang User Conference 2015.
You can find more info [here](https://www.erlang-factory.com/euc2015/stavros-aronis).
The slides are [here](https://docs.google.com/presentation/d/1dRUQ1jC0NXRyM-6WJWo15n-3hSZ1p7F8fl3X4bdhis8/pub?start=false&loop=false&delayms=60000).
================================================
FILE: docs/_posts/2017-08-14-euc-2017-talk.md
================================================
---
layout: post
title: "Talk at EUC 2017: Video and Slides"
category: news
redirect_from: /euc-2017-talk.html
---
Kostis Sagonas presented a talk on Concuerror at the Erlang User Conference 2017.
{% assign yt-link = "WWBDUpmCUsI" %}
{% include yt.html %}
[Get the slides](https://docs.google.com/presentation/d/11nidXG5JazNXsNSoqW98oRlx7-e64ghQ_E1p_WMLitg).
You can find more info [here](https://www.erlang-factory.com/euc2017/kostis-sagonas).
================================================
FILE: docs/_posts/2017-08-14-euc-2017-tutorial.md
================================================
---
layout: post
title: "Tutorial at EUC 2017: Slides"
category: tutorials
---
Stavros Aronis presented a tutorial on Concuerror at the Erlang User Conference 2017.
You can find more info [here](https://www.erlang-factory.com/euc2017/stavros-aronis).
The slides are [here](https://goo.gl/Mhulbn).
================================================
FILE: docs/_posts/2017-10-03-publications-update.md
================================================
---
layout: post
title: "Recent Publications and Homepage"
category: news
redirect_from: /publications-update.html
---
The [Publications](/publications) page was updated with some recent publications.
The [Homepage](/) was extended with more info.
================================================
FILE: docs/_posts/2017-10-08-concuerror-eunit.md
================================================
---
layout: post
title: "How to run Concuerror with EUnit"
category: tutorials
updated: 2018-03-09
---
Here are some guidelines on how to use Concuerror as part of an EUnit
suite.
First of all, the "order" in which you run the two tools is
significant: e.g. invoking Concuerror with the `test/0` function
generated by EUnit is a bad idea, for at least two reasons:
1. you probably don't want to test all of EUnit's boilerplate code
systematically and
2. the default test function generated by EUnit runs all tests, one
after another; as a result, systematic testing will have to explore
a number of schedulings that is the **product** of every individual
test's schedulings! You should use Concuerror on single tests
instead.
Suppose you have the following EUnit tests:
{% highlight erlang %}
-module(eunit_sample).
-include_lib("eunit/include/eunit.hrl").
%%==============================================================================
foo_test() ->
?assert(true).
msg_test() ->
P = self(),
spawn(fun() -> P ! foo end),
spawn(fun() -> P ! bar end),
receive
Msg -> ?assert(foo, Msg)
end.
reg_test() ->
Fun =
fun() ->
receive message -> ok
after 100 -> timeout
end
end,
P = spawn(Fun),
register(p, P),
p ! message,
?assert(true).
{% endhighlight %}
For this suite, running EUnit yields:
{% highlight bash %}
$ erlc eunit_sample.erl
$ erl -noinput -s eunit_sample test -s erlang halt
All 3 tests passed.
{% endhighlight %}
It is fairly easy to see, however, that the two latter tests can fail
in particular interleavings[^1].
[^1]: In fact, the second and third tests MAY fail once in a while, but most times they won't!
Invoking Concuerror on `msg_test/0` easily finds the error:
{% highlight bash %}
$ concuerror -m eunit_sample -t msg_test
Concuerror v0.17 (...) started at 08 Oct 2017 16:19:48
[...]
Errors were found! (check concuerror_report.txt)
Done at 08 Oct 2017 16:23:49 (Exit status: error)
Summary: 1 errors, 2/2 interleavings explored
{% endhighlight %}
The output file contains the trace:
{% highlight text %}
{% raw %}
Concuerror v0.17 (...) started at 08 Oct 2017 16:23:49
Options:
[...]
################################################################################
Interleaving #2
--------------------------------------------------------------------------------
Errors found:
* At step 6 process P exited abnormally
Reason:
{{assertEqual,[{module,eunit_sample},
{line,15},
{expression,"Msg"},
{expected,foo},
{value,bar}]},
[...]}
Stacktrace:
[...]
--------------------------------------------------------------------------------
Event trace:
1: P: P.1 = erlang:spawn(erlang, apply, [#Fun<eunit_sample.'-msg_test/0-fun-0-'.0>,[]])
in erlang.erl line 2693
2: P: P.2 = erlang:spawn(erlang, apply, [#Fun<eunit_sample.'-msg_test/0-fun-1-'.0>,[]])
in erlang.erl line 2693
3: P.2: bar = P ! bar
in eunit_sample.erl line 13
4: P.2: exits normally
5: P: receives message (bar)
in eunit_sample.erl line 14
6: P: exits abnormally ({{assertEqual,[{module,eunit_sample},{line,15},..]}})
7: P.1: foo = P ! foo
in eunit_sample.erl line 12
8: P.1: exits normally
################################################################################
Exploration completed!
################################################################################
[...]
Info:
--------------------------------------------------------------------------------
* Automatically instrumented module io_lib
* Automatically instrumented module gen_server
* Automatically instrumented module eunit_sample
* Automatically instrumented module erlang
* You can see pairs of racing instructions (in the report and '--graph') with '--show_races true'
################################################################################
Done at 08 Oct 2017 16:23:49 (Exit status: error)
Summary: 1 errors, 2/2 interleavings explored
{% endraw %}
{% endhighlight %}
Notice that Concuerror instrumented only some very basic modules. In
contrast, invoking Concuerror on the `test/0` function that is
automatically generated by EUnit (and is automatically tested by
Concuerror), yields:
{% highlight text %}
$ concuerror -m eunit_sample
Concuerror v0.17 (...) started at 08 Oct 2017 16:28:38
Writing results in concuerror_report.txt
* Info: Automatically instrumented module io_lib
* Info: Automatically instrumented module gen_server
* Info: Automatically instrumented module eunit_sample
* Info: Automatically instrumented module eunit
* Info: Automatically instrumented module proplists
* Info: Automatically instrumented module eunit_tty
* Info: Automatically instrumented module eunit_listener
* Info: Automatically instrumented module erlang
* Info: Automatically instrumented module eunit_serial
* Info: Automatically instrumented module sets
* Info: Automatically instrumented module lists
* Info: Automatically instrumented module eunit_lib
* Info: Automatically instrumented module gb_trees
* Info: Automatically instrumented module dict
* Info: Automatically instrumented module eunit_server
* Warning: Your test seems to try to set up an EUnit server. This is a bad idea, for at least two reasons: 1) you probably don't want to test all of EUnit's boilerplate code systematically and 2) the default test function generated by EUnit runs all tests, one after another; as a result, systematic testing will have to explore a number of schedulings that is the product of every individual test's schedulings! You should use Concuerror on single tests instead.
* Info: Automatically instrumented module queue
* Info: Automatically instrumented module eunit_proc
* Tip: Increase '--print_depth' if output/graph contains "...".
* Error: Stop testing on first error. (Check '-h keep_going').
* Error: Concuerror does not support calls to built-in erlang:statistics/1 (found in eunit_proc.erl line 324).
If you cannot avoid its use, please contact the developers.
Stacktrace:
[{eunit_proc,with_timeout,3,[{file,"eunit_proc.erl"},{line,324}]},
{eunit_proc,run_group,2,[{file,"eunit_proc.erl"},{line,549}]},
{eunit_proc,child_process,2,[{file,"eunit_proc.erl"},{line,353}]}]
Done at 08 Oct 2017 16:28:39 (Exit status: fail)
Summary: 1 errors, 1/1 interleavings explored
{% endhighlight %}
Concuerror does not support calls to
`erlang:statistics/1`. Additionally, it emits a *Warning* that this
particular use is problematic.
Fortunately, the EUnit suite can be extended to also run the tests
with Concuerror:
{% highlight erlang %}
%%==============================================================================
-define(concuerror_options, [{module, ?MODULE}, quiet]).
foo_concuerror_test() ->
?assertEqual(ok, concuerror:run([{test, foo_test}|?concuerror_options])).
msg_concuerror_test() ->
?assertEqual(ok, concuerror:run([{test, msg_test}|?concuerror_options])).
reg_concuerror_test() ->
?assertEqual(ok, concuerror:run([{test, reg_test}|?concuerror_options])).
{% endhighlight %}
Invoking Concuerror again, yields:
{% highlight bash %}
$ erlc eunit_sample.erl
$ erl -noinput -s eunit_sample test -s erlang halt
eunit_sample: msg_concuerror_test...*failed*
in function eunit_sample:'-msg_concuerror_test/0-fun-0-'/0 (/home/stavros/git/Concuerror/tests-real/suites/options/eunit/eunit_sample.erl, line 38)
**error:{assertEqual,[{module,eunit_sample},
{line,38},
{expression,"concuerror : run ( [ { test , msg_test } | ? concuerror_options ] )"},
{expected,ok},
{value,error}]}
output:<<"">>
eunit_sample: reg_concuerror_test...*failed*
in function eunit_sample:'-reg_concuerror_test/0-fun-0-'/0 (/home/stavros/git/Concuerror/tests-real/suites/options/eunit/eunit_sample.erl, line 41)
**error:{assertEqual,[{module,eunit_sample},
{line,41},
{expression,"concuerror : run ( [ { test , reg_test } | ? concuerror_options ] )"},
{expected,ok},
{value,error}]}
output:<<"">>
=======================================================
Failed: 2. Skipped: 0. Passed: 4.
{% endhighlight %}
The second and third tests have failed as expected and if run
individually you can debug them from the report.
Have fun and keep testing!
================================================
FILE: docs/_posts/2017-10-14-concuerring-concuerror-ep-1.md
================================================
---
layout: post
title: "Concuerring Concuerror"
category: tutorials
redirect_from: /concuerring-concuerror-ep-1.html
---
### ... and some useful lessons for testing complex applications.
Developers learn the term 'heisenbug' when they run their concurrent
code and see it succeeding and failing 'randomly'. Concurrent
programming is hard and errors in concurrent programs are difficult to
trigger and debug. Changing the program makes the bug go away. Tools
that can detect such errors are complex, usually have limited
abilities and are difficult to use. Hope must be abandoned.
Concuerror, a stateless model checking tool capable of detecting
concurrency errors in Erlang programs, recently started showing
symptoms of suffering from a heisenbug itself. Some of the continuous
integration jobs on
[Travis CI](https://travis-ci.org/parapluu/Concuerror) would get stuck
and timeout due to inactivity
([here](https://travis-ci.org/parapluu/Concuerror/builds/286063501)
[are](https://travis-ci.org/parapluu/Concuerror/builds/286108892)
[a](https://travis-ci.org/parapluu/Concuerror/builds/286510470)
[few](https://travis-ci.org/parapluu/Concuerror/builds/286544528)).
Starting those jobs again would sometimes make them succeed. Other,
local runs of the test suite, would sometimes crash with Concuerror's
own timeout message ('a process did not respond...'). These crashes
would notably show up at different points within Concuerror's
exploration of program schedulings.
These are all symptoms of heisenbugs.
A fairly common challenge for a program whose input is some other
program (e.g. compilers, code analyzers, etc) is to run such program
with itself as input. Especially for analysis tools, such as
Concuerror, the goal is to assert that the program does not suffer
from the errors it can detect.
This is also known as
"[eating one's own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food)".
Could Concuerror find the concurrency bug it had? As its main
developer I wanted the answer to be an easy "yes". Sadly, the
complexity of the tool itself was initially too high for such a task.
Thus began project
[`dogfood`](https://github.com/aronisstav/Concuerror/tree/dogfood).
Concuerror should be able to analyze itself, either by supporting more
features or by not using them at all. As the 'Concuerror under test'
would still need an
[input](https://en.wikipedia.org/wiki/Turtles_all_the_way_down), the
simplest Erlang function was picked: `test() -> ok.`.
The stage was set for a (very nerdy) action film!
## Instrumentation and Code loading
One of Concuerror's most useful features is its ability to find source
code, instrument it, recompile and reload it on an Erlang VM
[in a totally automatic and seamless way](/tutorials/basic-tutorial.html/#-is-it-really-that-simple).
Doing this as part of a test, however, would require handling files
and this is a very hard task in stateless model checking. In Erlang,
this could entail unloads, resets and other similar horrors.
Fortunately, Concuerror lets programs communicate with existing
registered Erlang processes and allows them to read public ETS
tables. Concuerror is using such an ETS table to mark code that has
been already instrumented and loaded. By appending a run of the simple
test input before the run of 'Concuerror under test' on that input,
any code that needed instrumentation would be readily instrumented
when inspected by the inner Concuerror.
It is unclear how this trick can be generalized. Using files or ports
is still hard in code under stateless model checking.
## Unsupported operations
The next challenge was in the use of several Erlang builtin operations
whose handling has not yet been implemented in Concuerror. Examples
include operations that are
[fairly problematic to begin with (e.g. `os:timestamp`)](/faq/#limitations)
and others that are simply not yet implemented
(e.g. `ets:update_element`). Such operations were either simplified in
the tool or minimal support for them was added. The last approach was
easy, as Concuerror simulates very few parts of Erlang; letting the
tool 'just run' the operations (and consider them racing with
everything else) is a good first approximation.
## Full sequentialization
An early goal of the self-analysis was to assert that Concuerror would
be a fully sequential tool: only one process could run at anytime, a
constraint that could be enforced by synchronous requests between the
components of the application. This approach was abandoned early as
full sequentialization of the communication with the logger component
was deemed too silly.
Concurrent operations would instead be allowed, but any racing
operations would be eliminated.
## Looking at the magic
Once the first issues were handled, tests started showing a trace of
events before getting stuck here or crashing there. This was the first
time I saw how much is going on in a run of Concuerror. ETS tables
were written and read, messages and signals were flying. I was
dazzled.
A number of simplifications were done using this info. When the
analysis is over, processes can be
[gently signaled to exit](https://github.com/parapluu/Concuerror/commit/cd55afb)
(Concuerror used to kill them, something which is discouraged in
systematic testing, as such kill signals race with almost every other
operation). Some synchronization was
[added](https://github.com/parapluu/Concuerror/commit/c20def7) in
places where it would retain simplicity in the code.
## Improving the user experience
Eating one's own dog food reveals small frustrating details that can
ruin user experience. Badly formed options that are ignored. Unclear
messages to the user. Sanding those hard edges is trivial once they
are detected. Using the tool for real is the only way to do so.
## Simplifying the code
In the end, solving a tricky knot involving the marking of 'processes
under Concuerror' and the handling of `receive` statements split the
commit history of the 'dog food' branch into two parts:
* Before the
[fix](https://github.com/parapluu/Concuerror/commit/c1c641e),
Concuerror could not analyze itself: messages would be mysteriously
lost between the outer and inner instances and the outer instance
would get always stuck. This was not surprising: recursive use of
the tool is (still) an esoteric endeavor and getting the
instrumentation right is tricky.
* After the fix, Concuerror **could analyze itself!** However, the
analysis would terminate after exploring just one scheduling, which
was correct. No races existed.
Was it the case that the bug was still there, but could only be
triggered with more complex input? That's what I initially
thought. Stateless model checking is a very practical technique for
finding concurrency errors, but cannot cover all inputs of a program
under test.
The reason to believe that the bug had not been fixed was that the fix
was just preventing a send operation from being instrumented by moving
it elsewhere. To avoid introducing a race **due** to the movement,
another send operation was also moved. Their order remained the
same. Or so I thought.
## Fixing the bug
Concuerror instruments and reloads code in a way that is completely
transparent, unless a process has been 'marked' by the tool. Marked
processes mostly execute their original code, but wait for permission
from Concuerror's scheduler before performing any operations that
could be involved in races and also notify the scheduler about the
result of any such operation.
When a process under Concuerror receives a message, Concuerror's
instrumentation intercepts it and places it in a separate queue. This
is done because Concuerror's scheduler itself communicates with
processes via messages and this interception keeps channels of
communication clean.
When a process under Concuerror is about to execute a receive
statement, the instrumentation inspects the patterns, the existence of
an after clause and the messages in the queue. If a matching message
is found it's "sent again" (the first send in the story above), so
that the actual receive statement can then be executed, finding the
message in the mailbox. If no intercepted message matches but an after
statement should be executed, no message should be placed in the
mailbox.
In either case, the process would notify Concuerror's scheduler,
sending a message to it (the second send in the story above) *before*
executing the actual receive statement.
This opened up the possibility that the scheduler would send a message
of its own, asking for the next event, before the receive statement
was really executed. This was fine and well if a message was about to
be received (the message would already be in the mailbox), but if the
process was supposed to execute the after clause, it could
'accidentally' receive Concuerror's scheduler message.
The process might then crash. Or it might ignore the message and reach
the point before the next operation for which it would have to notify
the scheduler. It would then wait forever for the scheduler's message
(which was already accidentally consumed).
The scheduler would also either crash, blaming the process for not
responding within reasonable time to its request for a next event, or
wait forever (depending on the `--timeout` option used).
Having to do the possible "send again" as the absolutely last thing
(as this was the operation moved into uninstrumented code), forced the
notification to also be moved after the receive statement (with the
timeout) was completed. The scheduler's message could no longer be
lost. The test had only one interleaving.
The bug was fixed.
## ... and a philosophical question
In the version before the fix, Concuerror could **not** cleanly find
this bug, but was also prevented from running correctly: there was too
much instrumentation on the "sent again" handling of a message. After
a partial fix the bug could still not really be found: the `receive`
statement whose after clause was vulnerable would be uninstrumented
(all the inspection would have happened beforehand).
Yet, in the version after the fix, Concuerror did not have the bug.
So, at the end of the day, did Concuerror find the bug, or was it me?
:-)
================================================
FILE: docs/_posts/2017-11-06-Announcing-Mailing-List.md
================================================
---
layout: post
title: "Announcing a Mailing List"
category: news
redirect_from: /Announcing-Mailing-List.html
---
Concuerror now has a [mailing list](/contact).
================================================
FILE: docs/_posts/2018-07-15-hex.md
================================================
---
layout: post
title: "Available on Hex.pm (with API specification)"
category: news
redirect_from: /hex.html
---
Concuerror is now also available via
[Hex.pm](https://hex.pm/packages/concuerror).
Specification about its API is available on
[Hexdocs](https://hexdocs.pm/concuerror).
================================================
FILE: docs/_posts/2020-10-10-tips.md
================================================
---
layout: post
title: "How to optimize Concuerror's search?"
category: news
redirect_from: /tips.html
---
## Table of contents
{:.no_toc}
1. This text will be replaced by the ToC
{:toc}
This post contains tips for optimizing Concuerror's search.
## The bound options
Concuerror has a number of different bound-related options. These can
be used to reduce the search space is different ways.
### Depth bound
The depth bound (`-d, --depth_bound`) is a limit on how many
events[^1] there can be in a single
execution of the given test. Concuerror requires test executions to
have finite length, and the depth limit is a simple way to guarantee
that every execution has a limited number of events. However, **if an
execution reaches this limit Concuerror cannot prove correctness of
the test** (and it will report so but you can make it keep exploring
executions anyway).
### Interleaving bound
The interleaving bound (`-i, --interleaving_bound`) is a hard limit on
how many interleavings of the given test will be explored. Concuerror
is currently always deterministic, so, unless the test or other
options are modified, the same interleavings will be explored, in the
same order, and running a test repeatedly will not return different
results.
### Scheduling bound
Exploring all the interleavings of a concurrent program (and therefore
verifying it), even with Concuerror's specialized techniques, can lead
to exploring a number of interleavings that grows exponentially with
the length of the execution. If one is interested in finding bugs, on
the other hand, it might be fruitful to explore "simpler" schedulings
before trying more elaborate ones.
Concuerror can help achieve that goal by using a scheduling bound. As
explained in the Bounding chapter in ["Effective Techniques for
Stateless Model Checking"](/publications):
>This [goal] can be achieved using bounding techniques, that impose
constraints on how/when processes can be scheduled by a stateless
model checking algorithm and force the algorithm to focus the
exploration on schedulings that satisfy those constraints. In this
way, bugs in ‘simpler’ schedulings can be detected faster than when
using exhaustive exploration. Schedulings that violate the
constraints can also be explored, but each exploration begins with a
budget (also called a bound), which is spent whenever the algorithm
schedules processes in a way that violates the constraints. When no
budget remains, the SMC algorithm can only explore schedulings that
satisfy the constraints.
#### "Simpler" schedulings
When schedule bounding techniques are used, the "simplest" scheduling
is chosen by the combination of scheduling options, currently
`--scheduling` and `--strict_scheduling`.
#### Scheduling bound
The `-b, --scheduling_bound` option defines the value of the
scheduling bound.
#### Scheduling bound types
The possible options for scheduling bounding are
* `none` (default), if no scheduling bounding should be used
* `delay` (recommended, when using bounding, and selected by default
if a value is chosen for `--scheduling_bound` and no type is
specified), which in Concuerror does **not** correspond to the
technique found in other bibliography, but at a variant which we
have named "exploration tree bounding" in the same
publication[^2]. A benefit of this
technique is that it is compatible with any DPOR algorithm and leads
to fairly smooth scaling of the explored search space with the
increase of the bound.
* `bpor`, as described by \[16\] in the same publication[^3],
which is based on limiting the number
of times a process can be preempted. A practical weakness of this
technique is that when a process becomes blocked *any* other process
can be scheduled without consuming bounding budget, possibly leading
to unpredictable scaling behaviours.
* `ubpor`, which is a mostly abandoned experimental variant of `bpor`
and is not recommended.
## Using the bounds and optimizing your tests
This section provides some general guidelines on how to use Concuerror
effectively.
### See why Concuerror is exploring interleavings
Concuerror explores interleavings based on racing operations it
detects. Using the `log_all` option together with `show_races` (and a
small `interleaving bound`, to just sample the space of the test) can
let you see the racing operations in a test, and can be a useful aid
in simplifying.
### "Shutdown" sequences of OTP behaviours
If you are spawning processes using supervisors or OTP behaviours, it
is often the case that when your main test process finishes a cascade
of shutdowns will be triggered, which may or may not lead to more
races. If you are not interested in the behaviour of your processes
shutting down, blocking the main test process with a `receive after
infinity -> ok end` (and ignoring the deadlocks with `--ignore-error
deadlock`) might simplify your test.
### Start simple
Two or three processes and relatively simple test scenarios are enough
to trigger most race conditions. Even a simple "sequential
concatenation" of two complex racing scenarios will lead to a state
space that has the size of the product of the two individual scenarios
(Concuerror is dynamic and cannot know e.g. that the second scenario
always, independently follows the first).
### Use a scheduling bound
Using a scheduling bound can quickly and effectively lead to a better
search for bugs in your tests. A good way to summarize this is: "if
you suspect a bug is there, a small scheduling bound will find it".
### Read the hints
Concuerror emits hints upon detecting some patterns that may lead to
unexpected explosion of the search space. Reading and understanding
them is recommended.
## Final note
Concuerror is a fairly expert tool and mastering its use requires
practise. If you have further questions consider communicating over
the [suggested channels](/contact)!
[^1]: As events, Concuerror considers any kind of Erlang built-in
operation that can be potentially interfering with operations in
other processes, such as the delivery of a message, the expiration
of a timeout, or writing and reading values in an ETS table. If
you are interested in a snapshot of what kind of operations in
Erlang programs can interfere, read the paper ["The shared-memory
interferences of Erlang/OTP built-ins"](/publications).
[^2]: ["Effective Techniques for Stateless Model
Checking"](/publications)
[^3]: Same as above.
================================================
FILE: docs/_posts/2020-10-17-code-beam-sf-2019.md
================================================
---
layout: post
title: "Talk at CODE BEAM SF 2019: Slides"
category: news
redirect_from: /code-beam-sf-2019.html
---
Stavros Aronis presented a talk on Concuerror at CODE BEAM 2019.
You can find more info [here](https://codesync.global/speaker/stavros-aronis/#301modeling-and-verifying-distributed-applications-with-concuerror).
The slides are [here](/assets/pdf/CodeBEAMSF2019.pdf).
================================================
FILE: docs/_posts/2020-10-17-functional-conf-2018.md
================================================
---
layout: post
title: "Talk at Functional Conf 2018: Video and Slides"
category: news
redirect_from: /functional-conf-2018.html
---
Stavros Aronis presented a talk on Concuerror at Functional Conf 2018.
{% assign yt-link = "xAoIn_3b_n8" %}
{% include yt.html %}
You can find more info [here](https://confengine.com/functional-conf-2018/proposal/8528/conquering-race-conditions-in-erlang-programs-with-concuerror).
The slides are [here](https://drive.google.com/file/d/11dhg9lG2v1cHpDrgLPcUlVvna39qHVFG/preview?feature=oembed).
================================================
FILE: docs/_posts/2020-10-24-basic-tutorial.md
================================================
---
layout: post
category: tutorials
---
Before you launch Concuerror, you need a test that is **terminating**
(ideally in any scheduling of the processes) and **closed** (does not
require any inputs).
You should also keep in mind that systematic testing (unlike
stress-testing) does not encourage (or require) the use of too many
processes! **All** schedulings of the test will be explored, so "the
simpler, the better"!
Once you have such a test, all you have to do is compile your code as
usual (preferably with `debug_info`) and then invoke Concuerror from
your shell, specifying the module and function that contains your
test:
{% highlight bash %}
$ concuerror -m my_module -t my_test
{% endhighlight %}
You can also invoke `concuerror:run/1` from an Erlang shell:
{% highlight erlang %}
1> concuerror:run([{module, my_module}, {test, my_test}]).
{% endhighlight %}
or:
{% highlight erlang %}
2> concuerror:run([{entry_point, {my_module, my_test, []}]).
{% endhighlight %}
The tool automatically instruments any modules used in the test, using
Erlang's automatic code loading infrastructure, so nothing more is in
principle needed!
Read the [FAQ](/faq) for more help.
## ... is it really that simple?
Well, for many programs that is probably enough! If your test is
named `test` you can even skip the `-t` option!
If a scheduling leads to one or more processes crashing or
deadlocking, Concuerror will print a detailed trace of all the events
that lead to the error and by default stop the exploration. You can
then use this trace to debug the detected error.
Otherwise it will keep exploring schedulings, until it has checked
them all. [Will the exploration ever
finish?](/faq/#will-the-exploration-ever-finish)
## Read more
A more detailed introductory tutorial, including sample code is
available [here](/tutorials/poolboy-example.html).
[Check out more tutorials here!](/tutorials)
================================================
FILE: docs/contact.md
================================================
---
layout: page
permalink: /contact/index.html
title: "Contact"
description: "Information about contacting Concuerror's developers"
updated: 2018-02-22
---
Here is information about how to contact the developers.
## Mailing List
The preferred way of communication is the mailing list.
### Archives
<https://www.freelists.org/archive/concuerror>
### Subscribe
Send an email to
[concuerror-request@freelists.org](mailto:concuerror-request@freelists.org?subject=Subscribe&body=I+want+to+subscribe+to+Concuerror's+mailing+list!)
with 'Subscribe' in the Subject field
OR
Visit the list's page at <https://www.freelists.org/list/concuerror>.
### FAQ
You can find FAQ about mailing lists hosted by freelists.org at
<https://www.freelists.org/wiki/the_faq>.
================================================
FILE: docs/download.md
================================================
---
layout: page
permalink: /download/index.html
title: "Download Concuerror"
description: "Information on how to download Concuerror."
---
## Github
Concuerror's latest stable version is available on [Github](https://github.com/parapluu/Concuerror):
{% highlight bash %}
$ git clone https://github.com/parapluu/Concuerror.git
$ cd Concuerror
$ make
{% endhighlight %}
The preferred way to start concuerror is via the `bin/concuerror` escript.
## Hex.pm
Concuerror is also [available via Hex.pm](https://hex.pm/packages/concuerror).
This enables you to include it in your project using any of the
building tools that support Hex.pm dependencies.
## Supported OTP Releases
See [Supported OTP
Releases](https://github.com/parapluu/Concuerror#supported-otp-releases).
We use [Github Actions](https://github.com/parapluu/Concuerror/actions) to test:
* The *two last* minor versions of the 'current' major Erlang/OTP release
* The *last* minor version of recent older major releases
You can also find older versions of Concuerror
[here](https://github.com/mariachris/Concuerror.git).
================================================
FILE: docs/faq.md
================================================
---
layout: page
permalink: /faq/index.html
title: "Concuerror's FAQ"
description: "Concuerror's Frequently Asked Questions"
updated: 2017-10-16
---
# Frequently Asked Questions
{:.no_toc}
1. This text will be replaced by the ToC, excluding the previous header (WOW!)
{:toc}
## How do I report a bug?
The preferred way is to use the repository's [Issues
page](https://github.com/parapluu/Concuerror/issues/new), but you can also [contact the developers]({% link contact.md %}) in other ways.
## How can I tell Concuerror where to find the code used by my test?
Concuerror automatically instruments and reloads any code used by your test transparently relying on Erlang's code path.
It also supports a number of familiar options to specify input files.
Check `concuerror -h input` for more info.
## Will the exploration ever finish?
Complex concurrent programs can have a LOT of schedulings! Concuerror
uses a technique called Optimal Dynamic Partial Order Reduction to
filter through them and has special knowledge about the interferences
of Erlang/OTP built-ins (see the relevant [Publications](/publications)).
Still, all this reduction power may sometimes not be enough.
If Concuerror keeps running for a while, you may want to limit the exploration
(using e.g. the `--interleaving_bound` option)
and visualize the explored schedulings
via the `--graph` option (the [dot](https://graphviz.org/) tool
is needed to produce an image).
You can then see which operations the tool considers as racing
using the `--show_races` option and possibly simplify the test.
Concuerror may also print tips during its execution,
suggesting ways to improve the effectiveness of testing.
A large number of options are available to fine tune the tool.
You can find out more about them by using `--help all`.
## Can Concuerror do 'random testing'?
A 'random testing' mode has not yet been implemented in Concuerror (add
your voice to the related
[Issue page](https://github.com/parapluu/Concuerror/issues/16)).
If your goal is not verification, Concuerror has its own way to sample
the interleavings in a less systematic way: schedule bounding. You can
read more about it by `--help bound`.
## How does Concuerror work? (extended)
Concuerror runs the program under test in a controlled way so that only one
process runs at a time.
1. It begins with an arbitrary initial run, during which it logs any operations
that affect shared state, such as sending and delivery of messages,
operations on ETS tables etc. The result is a sequence of such events, called
an *interleaving*.
2. Afterwards it analyses this interleaving, finding pairs of events that could
have different results if they were to happen in the reverse order (e.g. a
message being delivered before the receiving process could have executed an
after clause instead).
3. Then it "plans" new interleavings of the program that will force this reverse
order for each such pair. Any such interleavings "replay" some events from
the one currently analyzed up to some instruction and then diverge, in order
to execute other events before those involved in a race.
4. Finally it checks for the "latest" place where it has made such a "plan",
actually replays all events up to that point and continues as described in
the plan. At some point in this new interleaving new behaviours may emerge.
5. It repeats this approach from step 2, until no other such plans remain.
This is a technique known as _stateless model checking with dynamic
partial order reduction_ ([read more](/publications)).
## How does Concuerror control the scheduling of processes?
Concuerror automatically adds instrumentation code and reloads any module that
is used by the test. The instrumentation forces any process involved in the test
to stop and report any operation that affects shared state.
## Does Concuerror support all of Erlang's operations/libraries?
Concuerror supports the complete Erlang language and can instrument programs of
any size. It can be the case that support for some built-in operations is not complete
but this is a matter of prioritization of tasks.
There are however certain limitations regarding e.g.
[timeouts](#how-does-concuerror-handle-timeouts-and-other-time-related-functions)
and [non-deterministic
functions](#how-does-concuerror-handle-non-deterministic-functions).
## How can I get rid of '...' in output files?
Use a higher `--print_depth`.
## Is there a mailing list?
[Yes]({% link contact.md %})!
## Is there a changelog?
[Yes](https://github.com/parapluu/Concuerror/blob/master/CHANGELOG.md)!
## Limitations
### How does Concuerror handle timeouts and other time-related functions?
#### Timeouts
Timeouts may appear as part of an Erlang
[`receive`](https://www.erlang.org/doc/system/expressions.html#receive)
statement or calls to
[`erlang:send_after/3`](https://www.erlang.org/doc/apps/erts/erlang.html#send_after/3) and
[`erlang:start_timer/3`](https://www.erlang.org/doc/apps/erts/erlang.html#start_timer/3). Due
to the fact that Concuerror's instrumentation has an overhead on the execution
time of the program, Concuerror normally disregards the actual timeout values
and assumes:
* **For** `receive` **timeouts**: the `after` clause is always assumed to be
possible to reach. Concuerror *will* explore interleavings that trigger the
`after` clause, unless it is impossible for a matching message to not have
arrived by the time the `receive` statement is reached.
* **For** `send_after`**-like timeouts**: The timeout message may arrive at
any time until canceled.
You can use `-- after-timeout N` to make Concuerror regard timeouts higher than
`N` as infinity.
#### Time-related functions (E.g. `erlang:time/0`)
Concuerror handles such functions together with other [non-deterministic
functions](#how-does-concuerror-handle-non-deterministic-functions).
### How does Concuerror handle non-deterministic functions?
The first time Concuerror encounters a non-deterministic function it records the
returned result. In every subsequent interleaving that is supposed to
'branch-out' *after* the point where the non-deterministic function was called,
the recorded result will be supplied, to ensure consistent exploration of the
interleavings.
This may result in unexpected effects, as for example measuring elapsed time by
calling `erlang:time/0` twice may use a recorded result for the first call and
an updated result for the second call (if it after the branching-out point),
with the difference between the two increasing in every interleaving.
### How does Concuerror handle NIFs?
Concuerror cannot intercept, instrument or perform race analysis in modules using NIFs and is very likely to crash if such modules are used. Better support may be included in the future.
================================================
FILE: docs/feed.xml
================================================
---
layout: null
---
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">{{ site.title }}</title>
<generator uri="https://github.com/mojombo/jekyll">Jekyll</generator>
<link rel="self" type="application/atom+xml" href="{{ site.url }}/feed.xml" />
<link rel="alternate" type="text/html" href="{{ site.url }}" />
<updated>{{ site.time | date_to_xmlschema }}</updated>
<id>{{ site.url }}/</id>
<author>
<name>{{ site.owner.name }}</name>
<uri>{{ site.url }}/</uri>
<email>{{ site.owner.email }}</email>
</author>
{% for post in site.posts limit:20 %}
<entry>
<title type="html"><![CDATA[{{ post.title | cdata_escape }}]]></title>
<link>{% if post.link %}{{ post.link }}{% else %}{{ site.url }}{{ post.url }}{% endif %}</link>
<id>{{ site.url }}{{ post.id }}</id>
{% if post.modified %}<updated>{{ post.modified | to_xmlschema }}T00:00:00-00:00</updated>
<published>{{ post.date | date_to_xmlschema }}</published>
{% else %}<published>{{ post.date | date_to_xmlschema }}</published>
<updated>{{ post.date | date_to_xmlschema }}</updated>{% endif %}
<author>
<name>{{ site.owner.name }}</name>
<uri>{{ site.url }}</uri>
<email>{{ site.owner.email }}</email>
</author>
<content type="html">{{ post.excerpt | xml_escape }}
<p><a href="{{ site.url }}{{ post.url }}">{{ post.title }}</a> was originally published by {{ site.owner.name }} at <a href="{{ site.url }}">{{ site.title }}</a> on {{ post.date | date: "%B %d, %Y" }}.</p></content>
</entry>
{% endfor %}
</feed>
================================================
FILE: docs/index.md
================================================
---
layout: page
updated: 2020-10-25
description: "Homepage of the Concuerror, a tool for debugging, testing and verifying concurrent Erlang programs."
---
**Concuerror** is a **stateless model checking tool** for **Erlang**
programs. It can be used to **detect** and **debug** concurrency
errors, such as **deadlocks** and errors due to **race conditions**.
Moreover it can **verify** the absence of such errors, because it
tests programs **systematically**, unlike techniques based on
randomness.
<div class="animated fadeInDown text-center" markdown="1">
[Get Concuerror!](/download){: .btn .btn--success .btn--large }
</div>
## Latest News
[Read the latest news here](/news).
## How to use Concuerror?
[Read the basic tutorial here]({% post_url 2020-10-24-basic-tutorial %}).
## What are race conditions?
Concuerror's operation is based on detecting pairs of operations that
are racing, i.e. could have a different result if scheduled in the
opposite order. You can see some of these pairs by using the
[`--show_races`
option](https://hexdocs.pm/concuerror/concuerror_options.html#show_races_option-0).
Remember, however, that not all race conditions are necessarily bad!
An example of benign racing is when worker processes report their
progress by sending messages to a work managing process. These
messages are racing, as they may reach (and be received) by the
managing process in different orders.
Race conditions become can lead to errors when the program expects
certain events to occur in a particular order, but that order is not
always guaranteed. Such errors are often hard to reproduce, when they
require rare, particular schedulings.
Concuerror systematically explores all "meaningfully different"
schedulings, detecting all such errors or verifying their absence.
## How does Concuerror work?
Concuerror schedules the Erlang processes spawned in the test as if
only a single scheduler was available. During execution, the tool
records a trace of any calls to built-in operations that can behave
differently depending on the scheduling (e.g., receive statements,
registry operations, ETS operations). It then analyzes the trace,
detecting pairs of operations that are really racing. Based on this
analysis, it explores more schedulings, reversing the order of
execution of such pairs. This is a technique known as _stateless
model checking with dynamic partial order reduction_.
[Read more details about how Concuerror works here](/faq/#how-does-concuerror-work-extended).
================================================
FILE: docs/news.md
================================================
---
layout: posts
permalink: /news/index.html
title: News
description: "Links to all posts on this website, sorted by date."
show_excerpts: false
---
================================================
FILE: docs/publications.md
================================================
---
layout: page
permalink: /publications/index.html
title: Publications
description: "Scientific publications regarding and involving Concuerror."
updated: 2020-10-03
---
This is a list of publications related to Concuerror. Most titles are
links to official versions of the articles.
## Dissertation
<div style="margin-left:25px" markdown="1">
[**Effective Techniques for Stateless Model Checking**](https://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-333541)<br />
Stavros Aronis.<br />
PhD Dissertation, Uppsala University, 2018.
</div>
## Papers
<p>
<!-- ACM DL Article: Modelling distributed Erlang within a single node -->
<div class="acmdlitem" id="item3242764"><img src="https://dl.acm.org/images/oa.gif" width="25" height="25" border="0" alt="ACM DL Author-ize service" style="vertical-align:middle"/><a href="https://dl.acm.org/authorize?N663452" title="Modelling distributed Erlang within a single node" markdown="1">**Modelling distributed Erlang within a single node**</a><div style="margin-left:25px"><a href="https://dl.acm.org/author_page.cfm?id=81488667954" >Stavros Aronis</a>, <a href="https://dl.acm.org/author_page.cfm?id=99658635518" >Viktória Fördős</a>, and <a href="https://dl.acm.org/author_page.cfm?id=99659307811" >Dániel Szoboszlay</a><br />Erlang 2018 Proceedings of the 17th ACM SIGPLAN International Workshop on Erlang, 2018</div></div>
<!-- ACM DL Bibliometrics: Modelling distributed Erlang within a single node-->
<div class="acmdlstat" id ="stats3242764"><iframe src="https://dl.acm.org/authorizestats?N663452" width="100%" height="30" scrolling="no" frameborder="0">frames are not supported</iframe></div>
</p>
<div style="margin-left:25px" markdown="1">
[**Optimal Dynamic Partial Order Reduction with Observers**](https://rdcu.be/LLeU)<br />
Stavros Aronis, Bengt Jonsson, Magnus Lång, and Konstantinos Sagonas.<br />
TACAS 2018, Tools and Algorithms for the Construction and Analysis of Systems. Lecture Notes in Computer Science, vol 10806, 2018.<br />
<span class="small">
The official publication is available at link.springer.com via [its DOI link](https://doi.org/10.1007/978-3-319-89963-3_14).
</span>
</div>
<div style="margin-left:25px" markdown="1">
[**Testing and Verifying Chain Repair Methods for Corfu Using Stateless Model Checking**](/assets/pdf/iFM2017.pdf)<br />
Stavros Aronis, Scott Lystig Fritchie, and Konstantinos Sagonas.<br />
IFM 2017, Integrated Formal Methods: Proceedings of the 13th International Conference, 2017.<br />
<span class="small">
The official publication is available at link.springer.com via [its DOI link](https://doi.org/10.1007/978-3-319-66845-1_15).
</span>
</div>
<p>
<!-- ACM DL Article: The shared-memory interferences of Erlang/OTP built-ins -->
<div class="acmdlitem" id="item3123573"><img src="https://dl.acm.org/images/oa.gif" width="25" height="25" border="0" alt="ACM DL Author-ize service" style="vertical-align:middle"/><a href="https://dl.acm.org/authorize?N46294" title="The shared-memory interferences of Erlang/OTP built-ins" markdown="1">**The shared-memory interferences of Erlang/OTP built-ins**</a><div style="margin-left:25px"><a href="https://dl.acm.org/author_page.cfm?id=81488667954" >Stavros Aronis</a> and <a href="https://dl.acm.org/author_page.cfm?id=81548020391" >Konstantinos Sagonas</a>.<br />Erlang 2017, Proceedings of the 16th ACM SIGPLAN International Workshop on Erlang, 2017.</div></div>
<!-- ACM DL Bibliometrics: The shared-memory interferences of Erlang/OTP built-ins-->
<div class="acmdlstat" id ="stats3123573"><iframe src="https://dl.acm.org/authorizestats?N46294" width="100%" height="30" scrolling="no" frameborder="0">frames are not supported</iframe></div>
</p>
<p>
<!-- ACM DL Article: Source Sets: A Foundation for Optimal Dynamic Partial Order Reduction -->
<div class="acmdlitem" id="item3073408"><img src="https://dl.acm.org/images/oa.gif" width="25" height="25" border="0" alt="ACM DL Author-ize service" style="vertical-align:middle"/><a href="https://dl.acm.org/authorize?N46293" title="Source Sets: A Foundation for Optimal Dynamic Partial Order Reduction" markdown="1">**Source Sets: A Foundation for Optimal Dynamic Partial Order Reduction**</a><div style="margin-left:25px"><a href="https://dl.acm.org/author_page.cfm?id=81100490166" >Parosh Aziz Abdulla</a>, <a href="https://dl.acm.org/author_page.cfm?id=81488667954" >Stavros Aronis</a>, <a href="https://dl.acm.org/author_page.cfm?id=81100619282" >Bengt Jonsson</a>, and <a href="https://dl.acm.org/author_page.cfm?id=81548020391" >Konstantinos Sagonas</a>.<br />Journal of the ACM (JACM), 2017.</div></div>
<!-- ACM DL Bibliometrics: Source Sets: A Foundation for Optimal Dynamic Partial Order Reduction-->
<div class="acmdlstat" id ="stats3073408"><iframe src="https://dl.acm.org/action/renderAuthorizerContentBib?doi=10.1145/3073408" width="100%" height="30" scrolling="no" frameborder="0">frames are not supported</iframe></div>
</p>
<p>
<!-- ACM DL Article: Optimal dynamic partial order reduction -->
<div class="acmdlitem" id="item2535845"><img src="https://dl.acm.org/images/oa.gif" width="25" height="25" border="0" alt="ACM DL Author-ize service" style="vertical-align:middle"/><a href="https://dl.acm.org/authorize?N87798" title="Optimal dynamic partial order reduction" markdown="1">**Optimal dynamic partial order reduction**</a><div style="margin-left:25px"><a href="https://dl.acm.org/author_page.cfm?id=81100490166" >Parosh Abdulla</a>, <a href="https://dl.acm.org/author_page.cfm?id=81488667954" >Stavros Aronis</a>, <a href="https://dl.acm.org/author_page.cfm?id=81100619282" >Bengt Jonsson</a>, and <a href="https://dl.acm.org/author_page.cfm?id=81100605481" >Konstantinos Sagonas</a>.<br />POPL '14, Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, 2014.</div></div>
<!-- ACM DL Bibliometrics: Optimal dynamic partial order reduction-->
<div class="acmdlstat" id ="stats2535845"><iframe src="https://dl.acm.org/action/renderAuthorizerContentBib?doi=10.1145/2578855.2535845" width="100%" height="30" scrolling="no" frameborder="0">frames are not supported</iframe></div>
</p>
<div style="margin-left:25px" markdown="1">
[**Systematic Testing for Detecting Concurrency Errors in Erlang Programs**](/assets/pdf/ICST2013.pdf)<br />
Maria Christakis, Alkis Gotovos, and Konstantinos Sagonas.<br />
ICST 2013, Proceedings of the International Conference on Software Testing, Verification and Validation (ICST), 2013.<br />
<span class="small">
The official publication is available at ieeexplore.ieee.org via [its DOI link](https://doi.org/10.1109/ICST.2013.50).
</span>
</div>
<p>
<!-- ACM DL Article: Test-driven development of concurrent programs using concuerror -->
<div class="acmdlitem" id="item2034664"><img src="https://dl.acm.org/images/oa.gif" width="25" height="25" border="0" alt="ACM DL Author-ize service" style="vertical-align:middle"/><a href="https://dl.acm.org/authorize?N49975" title="Test-driven development of concurrent programs using Concuerror" markdown="1">**Test-driven development of concurrent programs using Concuerror**</a><div style="margin-left:25px"><a href="https://dl.acm.org/author_page.cfm?id=81488671778" >Alkis Gotovos</a>, <a href="https://dl.acm.org/author_page.cfm?id=81481650826" >Maria Christakis</a>, and <a href="https://dl.acm.org/author_page.cfm?id=81100605481" >Konstantinos Sagonas</a>.<br />Erlang '11, Proceedings of the 10th ACM SIGPLAN workshop on Erlang, 2011.</div></div>
<!-- ACM DL Bibliometrics: Test-driven development of concurrent programs using concuerror-->
<div class="acmdlstat" id ="stats2034664"><iframe src="https://dl.acm.org/authorizestats?N49975" width="100%" height="30" scrolling="no" frameborder="0">frames are not supported</iframe></div>
</p>
## Theses
<div style="margin-left:25px" markdown="1">
[**Systematic Testing of Concurrent Erlang Programs: Some Experiences**](https://dx.doi.org/10.26240/heal.ntua.16898)<br />
Ilias Tsitsimpis.<br />
Diploma Thesis, National Technical University of Athens, 2013.
</div>
<div style="margin-left:25px" markdown="1">
[**Dynamic Systematic Testing of Concurrent Erlang Programs**](https://dx.doi.org/10.26240/heal.ntua.7193)<br />
Alkis Gotovos.<br />
Diploma Thesis, National Technical University of Athens, 2011.
</div>
================================================
FILE: docs/search.md
================================================
---
layout: search
permalink: /search/index.html
title: Search
description: "Search Concuerror's website"
---
================================================
FILE: docs/sitemap.xml
================================================
---
layout: null
---
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>{{ site.url }}</loc>
</url>
{% for post in site.posts %}
<url>
<loc>{{ site.url }}{{ post.url }}</loc>
</url>
{% endfor %}
</urlset>
================================================
FILE: docs/tutorials.md
================================================
---
layout: category
permalink: /tutorials/index.html
title: Tutorials
description: "Links to tutorials on how to use Concuerror, sorted by date."
show_excerpts: false
taxonomy: tutorials
---
This is a list of tutorials on how to use Concuerror.
If you are looking for documentation, check the
[API](https://hexdocs.pm/concuerror).
================================================
FILE: elvis.config
================================================
[{elvis, [{config,
[ #{ dirs => ["src"]
, filter => "*.erl"
, rules =>
[ {elvis_style, module_naming_convention,
#{ regex => "^concuerror(_[a-z]+)*$"
, ignore => []
}}
, {elvis_style, no_tabs}
, {elvis_style, no_trailing_whitespace}
, {elvis_style, macro_module_names}
, {elvis_style, operator_spaces,
#{ rules =>
[ {right, "++"}
, {left, "++"}
, {right, "->"}
, {left, "->"}
, {right, "!"}
, {left, "!"}
]}}
, {elvis_style, nesting_level, #{level => 5}}
, {elvis_style, god_modules,
#{ limit => 20
, ignore => [ concuerror_options
]
}}
, {elvis_style, no_if_expression}
, {elvis_style, function_naming_convention,
#{ regex => "^[a-z]{2}([a-z0-9]*_?)*$"}}
, {elvis_style, state_record_and_type}
, {elvis_style, no_spec_with_records}
, {elvis_style, dont_repeat_yourself, #{min_complexity => 13}}
, {elvis_style, used_ignored_variable}
, {elvis_style, no_debug_call, #{ignore => []}}
]
}
, #{ dirs => ["src"]
, filter => "*.erl"
, rules =>
[ {elvis_style, operator_spaces,
#{ rules =>
[ {right, ","}
]
}}
, {elvis_style, line_length,
#{ limit => 80
, skip_comments => false
}}
]
, ignore =>
[ concuerror_dependencies
]
}
, #{ dirs => ["."]
, filter => "rebar.config"
, rules =>
[ {elvis_project, no_deps_master_rebar, #{ignore => []}}
, {elvis_project, protocol_for_deps_rebar, #{ignore => []}}
]
}
]
}]}].
================================================
FILE: priv/concuerror
================================================
#!/usr/bin/env escript
%%! +S1 -boot start_clean -noshell -pa . -pa ebin
%% This script is used instead of the 'escriptized' version of the
%% tool to collect code coverage data, as it was not obvious how to
%% use cover with escript's embedded zip archive.
main(Args) ->
ScriptName = read_link(escript:script_name()),
ScriptDir = filename:dirname(ScriptName),
TopDir = filename:dirname(ScriptDir),
ExtraDirs =
[filename:join([TopDir, "_build", Profile, "lib", App, "ebin"]) ||
Profile <- ["default", "dev"],
App <- ["concuerror", "getopt"]
],
ok = code:add_pathsa(ExtraDirs),
concuerror:main(Args).
-spec read_link(file:filename()) -> file:filename().
read_link(Filename) ->
case file:read_link_all(Filename) of
{ok, Follow} -> read_link(Follow);
_Other -> Filename
end.
================================================
FILE: priv/generate_option_docfiles
================================================
#!/usr/bin/env escript
%%! -noshell -pa _build/docs/lib/concuerror/ebin
main(Dir) ->
concuerror_options:generate_option_docfiles(Dir).
================================================
FILE: priv/generate_version_hrl
================================================
#!/usr/bin/env escript
%%! -noshell
%% The expected argument is the latest OTP version supported by
%% Concuerror.
main([[LD, LU|_] = _LatestOTP]) ->
MasterMajor = list_to_integer([LD, LU]) + 1,
CurrentOTPRelease =
case erlang:system_info(otp_release) of
"R" ++ _ -> 16; %% ... or earlier
[D,U|_] -> list_to_integer([D,U])
end,
io:format("-define(OTP_VERSION, ~w).~n", [CurrentOTPRelease]),
add_befores_for(CurrentOTPRelease + 1, MasterMajor).
add_befores_for(Release, MasterMajor) when Release =< MasterMajor ->
add_before_for(Release),
add_befores_for(Release + 1, MasterMajor);
add_befores_for(_, _MasterMajor) -> ok.
add_before_for(Release) ->
io:format("-define(BEFORE_OTP_~p, true).~n", [Release]).
================================================
FILE: rebar.config
================================================
{minimum_otp_vsn, "20.0"}.
{erl_opts,
[ debug_info
, warn_export_vars
, warn_unused_import
, warn_missing_spec
, warn_untyped_record
]}.
{deps, [{getopt, "1.0.1"}]}.
{escript_incl_apps, [concuerror, getopt]}.
{escript_main_app, concuerror}.
{escript_name, concuerror}.
{escript_emu_args, "%%! +S1 -boot start_clean -noshell -pa . -pa ebin\n"}.
{pre_hooks,
[ {compile, "priv/generate_version_hrl 23 > src/concuerror_otp_version.hrl"}
, {edoc, "priv/generate_option_docfiles doc"}
]}.
{post_hooks,
[ {escriptize, "cp \"$REBAR_BUILD_DIR/bin/concuerror\" ./bin"}
]}.
{profiles,
[ {dev,
[ {erl_opts, [{d, 'DEV', "true"}]}
]}
, {docs,
[ {erl_opts, [{d, 'DOC', "true"}]}
]}
, {lint,
[ {plugins, [{rebar3_lint, "0.1.10"}]}
]}
, {native,
[ {erl_opts, [native]}
]}
, {pedantic,
[ {erl_opts, [warnings_as_errors]}
]}
, {test,
[ {erl_opts, [export_all, nowarn_missing_spec]}
]}
]}.
{edoc_opts,
[ {macros, [{'DOC', "true"}]}
, {preprocess, true}
, {title, "Concuerror's API specification"}
]}.
{dialyzer,
[ {warnings,
[ unmatched_returns
, unknown
]}
, {base_plt_apps,
[ compiler
, crypto
, erts
, getopt
, kernel
, stdlib
, syntax_tools
, tools
]}
]}.
{project_plugins, [covertool]}.
{cover_enabled, true}.
{cover_export_enabled, true}.
{covertool,
[ {coverdata_files,
[ "eunit.coverdata"
]}
, {include_apps, [concuerror]}
]}.
================================================
FILE: resources/DPOR_paper_material/DPOR_README
================================================
Optimal Dynamic Partial Order Reduction for Analysis of Concurrent Programs
---------------------------------------------------------------------------
Contents:
---------
1. Introduction
2. Prerequisites
3. Quick intro
4. Tests
5. Interesting details in the code
1. Introduction
---------------
The purpose of this readme file is to offer a brief guide around an
experimental version of the Concuerror tool, which was developed to include an
algorithm for optimal partial order reduction of the state space generated by
the exploration of concurrent applications written in the Erlang language.
The experimental functionality, as well as two more similar
extensions/modifications are enabled with command line options. The tool runs
the stable version, if these are not provided. The stable version supports a few
more Erlang built-in functions that require preemption points and has been
tested and integrated with a GUI. The experimental versions use the command line
interface.
2. Prerequisites
----------------
Concuerror is an Erlang application, so you will need an Erlang runtime system
to run it. Most Linux distributions have suitable packages. To run the original
Concuerror testsuite you will also need Python. The application startup and
shutdown relies on a bash script, so it is currently not possible to run
Concuerror on a Windows machine.
You can build the application using 'make'
CAUTION: This file's information refer to a version of the code that has been
tagged under git as 'POPL_submission'. Check out that version before
continuing.
3. Quick intro
--------------
Concuerror expects as input a set of Erlang source modules, a target function
and a preemption bound. Its output in results.txt are all the traces of the
program that had some concurrency error.
We explain each briefly the command line options:
- source files : are the files that will be instrumented to include preemption
points before built-in functions that may affect the global
state.
Option: -f <files>
- target function : is an exported function in one of the files given as
input. This is the function that will be run by the first
process.
Option: -t <Module> <Name> [<arg1> <arg2>] (arguments are optional. If none is
given, the function with 0 arity
will be called)
- preemption bound : designates how many 'unnecessary' preemptions are allowed
in the current run. Concuerror will always allow enabled
processes to run after a process has become blocked (by
trying to execute a receive when no matching messages are
in its mailbox) and will also allow processes to be
interrupted while still being enabled for other processes
to be scheduled instead as many times as the preemption
bound.
Option: -p <number or 'inf' for infinite bound> (default value is 2)
- versions : by default you will be running the stable version of
Concuerror. The following command line options can be used to
enable 3 alternative versions, based on the same machinery:
--dpor_fake : is a 'sanity' check version of Concuerror using the
modified scheduler, but treating all operations as
dependent. Should give results similar to those of
the stable version, with maybe a few more
interleavings.
--dpor : is our experimental extension. Uses simple source sets to
decide additional interleavings, together with our set of
rules for dependencies between Erlang built-in functions.
--dpor_flanagan : is a version using the algorithm proposed by
Flanagan and Godefroid, extended with sleep sets
as described in our cited paper.
Examples:
To run stable Concuerror on two modules test.erl and foo.erl in your home
directory, using test:run/0 as your starting function and infinite preemption
bound:
./concuerror -f ~/test.erl ~/foo.erl -t test run -p inf
To run the same test using our experimental extension:
./concuerror -f ~/test.erl ~/foo.erl -t test run -p inf --dpor
You can run ./concuerror --help for description of a few more command line
options.
4. Tests
--------
You can instantly run two different testsuites that showcase the experimental
version:
a) The dpor_tests collection
b) Concuerror's stable testsuite, which has been adapted slightly to run the
experimental version instead of the stable one.
Let's go into more details:
a) dpor_tests
-------------
This is a collection of motivating examples that were used during the
development of the experimental version. They include toy Erlang programs as
well as all the examples presented in the paper. The toy tests were written to
expose dependencies in the supported Erlang built-in functions and to showcase
the differences and strengths between the different versions of the tool.
The tests output is compared against a stored expected output to decide success
or failure. A few (less than 5, usually 1) of the tests are expected to fail: in
these cases a diff of the expected output and the real output should show
environment related changes, as the traces sometimes include information that is
environment sensitive.
These tests are in the dpor_tests directory and you can run all of them by:
dpor_tests/dpor_test
... and a specific test by:
dpor_tests/dpor_test dpor_tests/dpor_test/src/<test>.erl
The output is written in the dpor_tests/new_results directory and is compared
with the reference output in dpor_tests/results. If it differs the test is
reported as FAILED and the output is left for comparison. You can then use a
(graphical) diff tool (e.g. meld) to see the differences in the outputs.
You can of course run any of the tests with e.g.:
./concuerror -f dpor_tests/src/<test>.erl -t <test> <test> -p inf --dpor
Interesting tests in dpor_tests:
--------------------------------
- ets_dependencies.erl : This is the simple 2 readers vs 1 writer example.
- ets_dependencies_n.erl : This is the extended example presented in the paper.
You can run this example with a varying number of readers <N> like this:
T=ets_dependencies
./concuerror -f dpor_tests/src/$T.erl -t $T $T <N> -p inf --dpor
- file_system_example.erl : The file system example written in Erlang
- independent_receivers.erl : A test with just two interleavings, where stable
Concuerror explores 234300 interleavings.
- register_again.erl : A test showing usage of Erlang built in functions.
- ring_leader_election_symmetric : An implementation of leader election in a
set of processes connected in a ring.
- ring_leader_election_symmetric_buffer.erl : Same as before, with the
difference that here mailboxes are 'modeled' as separate processes in such a
way that 'sends' and 'receives' are also interleaved, leading to an
explosion in the number of explored interleavings.
- send_it_ets.erl : An example showing why send operations with the same message
to the same process must be also interleaved.
b) Concuerror's stable testsuite
--------------------------------
Concuerror's stable testsuite has also been run with --dpor to check for any
missing dependencies. The files are stored in testsuite/suites, including
reference results. Running the tests creates the testsuite/results (which can
again be diffed against the reference directory in case of failures).
You can run the suite by:
make test
87 of the tests are expected to fail because the reference results are those
obtained by running --dpor_fake. This is to show the difference, which in most
cases favors --dpor (unless an unsupported instruction is used, in which case
the program crashes).
The --dpor_fake results are in the dpor directories under each suite. They have
been compared against the results (stored in the vanilla directories) obtained
by running the stable version with a few added preemption points. These are in
turn comparable with the original results (stored in the results directories).
Interesting test in Concuerror's testsuite
------------------------------------------
- manolis_test_2workers: Corresponds to the rush_hour test presented in the
paper.
5. Interesting details in the code
----------------------------------
Apart from concuerror_rep.erl which has all the replacement functions for the
actual calls that are found in the instrumented modules, all the main algorithm
run from concuerror_sched.erl. The dependent/2 boolean function returns true
when two operations are dependent. The main loop of the algorithm is in the
explore/1 function. Finally the two different DPOR versions differ in the details
of add_all_backtracks/1 function.
================================================
FILE: resources/DPOR_paper_material/foo.erl
================================================
-module(foo).
-export([foo/0]).
foo() ->
P = self(),
spawn(fun() -> P ! a end),
spawn(fun() -> P ! b end),
spawn(fun() -> P ! c end),
receive
V -> V
after
0 -> bloo
end.
================================================
FILE: resources/DPOR_paper_material/foobar.erl
================================================
-module(foobar).
-export([foo/0]).
foo() ->
bar().
bar() ->
ok.
================================================
FILE: resources/DPOR_paper_material/my_test.erl
================================================
-module(my_test).
-export([test/1]).
test(small) ->
foo_test();
test(large) ->
foobar_test().
foo_test() ->
dialyzer:run([{files, ["/home/stavros/git/Concuerror/resources/DPOR_paper_material/foo.erl"]}, {from, src_code}]).
foobar_test() ->
dialyzer:run([{files, ["/home/stavros/git/Concuerror/foobar.erl"]}, {from, src_code}]).
================================================
FILE: resources/DPOR_paper_material/run_dialyzer.sh
================================================
#!/usr/bin/env bash
echo "\\hline"
for i in small large; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{$T} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./conc_dia.sh $i $t | grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/DPOR_paper_material/run_filesystem.sh
================================================
#!/usr/bin/env bash
T=file_system_example
echo "\\hline"
for i in 16 18; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{file\_system} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./concuerror_mem --noprogress -f testsuite/suites/dpor/src/$T.erl \
-t $T main $i -p inf $t \
| grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/DPOR_paper_material/run_indexer.sh
================================================
#!/usr/bin/env bash
T=indexer_example
echo "\\hline"
for i in 12 15; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{$T} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./concuerror_mem --noprogress -f testsuite/suites/dpor/src/$T.erl \
-t $T main $i -p inf $t \
| grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/DPOR_paper_material/run_last_zero.sh
================================================
#!/usr/bin/env bash
T=sleeping_races_8
echo "\\hline"
for i in 2 5 10; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{last_zero} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./concuerror_mem --noprogress -f testsuite/suites/dpor/src/$T.erl \
-t $T $T $i -p inf $t \
| grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/DPOR_paper_material/run_readers.sh
================================================
#!/usr/bin/env bash
T=readers
echo "\\hline"
for i in 2 8; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{$T} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./concuerror_mem --noprogress -f testsuite/suites/dpor/src/$T.erl \
-t $T $T $i -p inf $t \
| grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/DPOR_paper_material/run_rush_hour.sh
================================================
#!/usr/bin/env bash
T=rush_hour
echo "\\hline"
for i in -; do
f=0
for t in --dpor --dpor_source --dpor_classic; do
if [ $f -eq 0 ]; then
echo "\multirow{3}{*}{rush\_hour} & \multirow{3}{*}{$i} & "
echo -n " o-DPOR &"
elif [ $f -eq 1 ]; then
echo -n " & & s-DPOR &"
else
echo -n " & & DPOR &"
fi
f=$((f+1))
./concuerror_mem --noprogress -f testsuite/suites/resources/src/manolis/*.erl \
-t rush_hour test_2workers_benchmark -p inf $t | \
grep "OUT" | sed 's/OUT//'
done
echo "\\hline"
done
================================================
FILE: resources/bash_completion/concuerror
================================================
#!/bin/bash
# bash_completion for concuerror
# To use it, you can either:
# - Link the file to e.g. `/etc/bash_completion.d`
# - Run `. /path-to-the-file`, if you want to use it only for the current shell session
# - Add `[ -s "/path-to-the-file" ] && \. "/path-to-the-file"` to your e.g. `.bashrc` file
_concuerror()
{
# Keep this sorted alphabetically
long_opts="--after_timeout --assertions_only --assume_racing --depth_bound
--disable_sleep_sets --dpor --exclude_module --file --first_process_errors_only
--graph --help --ignore_error --instant_delivery --interleaving_bound --keep_going
--log_all --module --no_output --non_racing_system --observers --optimal --output --pa
--print_depth --pz --quiet --scheduling --scheduling_bound --scheduling_bound_type
--show_races --strict_scheduling --symbolic_names --test --timeout --treat_as_normal
--use_receive_patterns --verbosity --version"
# Keep this sorted alphabetically
opts="-a -b -c -d -f -g -h -i -k -m -o -q -s -t -v -x"
local cur prev
if type _get_comp_words_by_ref &>/dev/null ; then
_get_comp_words_by_ref cur prev
else
cur=$2 prev=$3
fi
case $prev in
--dpor)
COMPREPLY=($(compgen -W "none optimal persistent source" -- ${cur}))
;;
-f|--file|--pa|--pz)
_filedir
;;
-h|--help)
help_args="all attributes progress"
keywords="advanced basic bound console erlang errors experimental input output por visual"
COMPREPLY=($(compgen -W "${help_args} ${keywords}" -- ${cur}))
;;
-c|--scheduling_bound_type)
COMPREPLY=($(compgen -W "bpor delay none ubpor" -- ${cur}))
;;
--scheduling)
COMPREPLY=($(compgen -W "newest oldest round_robin" -- ${cur}))
;;
-a|--after_timeout|-i|--interleaving_bound|--timeout)
COMPREPLY=($(compgen -W "infinity" -- ${cur}))
;;
*)
if [[ ${cur} == --* ]] ; then
COMPREPLY=($(compgen -W "${long_opts}" -- ${cur}))
elif [[ ${cur} == -* ]] ; then
COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
else
_filedir
fi
;;
esac
}
complete -F _concuerror concuerror
================================================
FILE: resources/erlang_questions/dets_bugs/alt_dets_bugs.erl
================================================
-module(alt_dets_bugs).
-export([bug3/0, bug5/0, bug6/0]).
-include_lib("eunit/include/eunit.hrl").
%% should always print [{0,0}], but sometimes prints []
bug3() ->
dets:close(dets_table),
sched:yield(),
file:delete(dets_table),
sched:yield(),
dets:open_file(dets_table,[{type,bag}]),
sched:yield(),
spawn(fun() -> dets:open_file(dets_table,[{type,bag}]),
sched:yield()
end),
spawn(fun() ->
dets:insert(dets_table,[{0,0}]),
sched:yield(),
?assertEqual([{0,0}], get_contents(dets_table))
end).
%% should always print [{0,0}], but sometimes prints []
bug5() ->
Self = self(),
spawn(fun() ->
[dets:close(dets_table) || _ <- "abcdefghijkl"],
file:delete(dets_table),
Parent = self(),
{ok, _T} = dets:open_file(dets_table,[{type,bag}]),
sched:yield(),
spawn(fun() ->
dets:open_file(dets_table,[{type,bag}]),
sched:yield(),
Parent ! done
end),
spawn(fun() ->
dets:insert(dets_table,[{0,0}]),
sched:yield(),
?assertEqual([{0,0}], get_contents(dets_table)),
Parent ! done
end),
receive done -> receive done -> ok end end,
Self ! ok
end),
receive ok -> ok end.
bug6() ->
dets:open_file(dets_table,[{type,bag}]),
sched:yield(),
dets:close(dets_table),
sched:yield(),
dets:open_file(dets_table,[{type,bag}]),
sched:yield(),
spawn(fun() -> dets:lookup(dets_table,0),
sched:yield()
end),
spawn(fun() -> dets:insert(dets_table,{0,0}),
sched:yield()
end),
dets:insert(dets_table,{0,0}),
sched:yield(),
?assertEqual([{0,0}], match_object(dets_table)).
get_contents(Name) ->
Ret = dets:traverse(Name, fun(X)-> {continue,X} end),
sched:yield(),
Ret.
match_object(Name) ->
Ret = dets:match_object(Name,'_'),
sched:yield(),
Ret.
================================================
FILE: resources/erlang_questions/dets_bugs/dets_bugs.erl
================================================
-module(dets_bugs).
-export([bug1/0, bug2/0, bug3/0, bug4/0, bug5/0, bug6/0]).
%% should always print a boolean, but sometimes prints 'ok'
bug1() ->
{ok,T} = dets:open_file(dets_table,[{type,bag}]),
spawn(fun()->dets:insert(T,[]) end),
spawn(fun()->io:format("~p\n",[dets:insert_new(T,[])]) end).
%% causes a bug message to appear
bug2() ->
file:delete(dets_table),
T = dets:open_file(dets_table,[{type,set}]),
spawn(fun() -> dets:delete(T,0) end),
spawn(fun() -> dets:insert_new(T,{0,0}) end),
ok.
%% should always print [{0,0}], but sometimes prints []
bug3() ->
dets:close(dets_table),
file:delete(dets_table),
{ok,_T} = dets:open_file(dets_table,[{type,bag}]),
spawn(fun() -> dets:open_file(dets_table,[{type,bag}]) end),
spawn(fun() ->
dets:insert(dets_table,[{0,0}]),
io:format("~p\n",[get_contents(dets_table)])
end).
%% should always print [], but sometimes prints [{7,0}]
bug4() ->
dets:close(dets_table),
file:delete(dets_table),
{ok,_T} = dets:open_file(dets_table,[{type,bag}]),
dets:insert(dets_table,{7,0}),
spawn(fun() -> dets:open_file(dets_table,[{type,bag}]) end),
spawn(fun() ->
dets:delete(dets_table,7),
io:format("~p\n",[get_contents(dets_table)])
end).
%% should always print [{0,0}], but sometimes prints []
bug5() ->
Self = self(),
spawn(fun() ->
[dets:close(dets_table) || _ <- "abcdefghijkl"],
file:delete(dets_table),
Parent = self(),
{ok,_T} = dets:open_file(dets_table,[{type,bag}]),
spawn(fun() -> dets:open_file(dets_table,[{type,bag}]),
Parent ! done
end),
spawn(fun() ->
dets:insert(dets_table,[{0,0}]),
io:format("~p\n",[get_contents(dets_table)]),
Parent ! done
end),
receive done -> receive done -> ok end end,
Self ! ok
end),
receive ok -> ok end.
bug6() ->
dets:open_file(dets_table,[{type,bag}]),
dets:close(dets_table),
dets:open_file(dets_table,[{type,bag}]),
spawn(fun() -> dets:lookup(dets_table,0)
end),
spawn(fun() -> dets:insert(dets_table,{0,0})
end),
dets:insert(dets_table,{0,0}),
dets:match_object(dets_table,'_').
get_contents(Name) ->
dets:traverse(Name,fun(X)->{continue,X}end).
================================================
FILE: resources/flanagan.erl
================================================
%% -*- erlang-indent-level: 2 -*-
-module(flanagan).
-export([test/1, explore/2]).
%% -define(DEBUG, true).
%% -define(STEPWISE, true).
-define(STATS, true).
-define(STACK, true).
-ifdef(DEBUG).
-ifndef(STACK).
-define(STACK, true).
-endif.
-endif.
%%------------------------------------------------------------------------------
-record(state, {
i,
last,
pstates,
backtrack = [],
done = []
}).
-record(pstate, {
commands,
mailbox = 0
}).
%%------------------------------------------------------------------------------
%% Sample Inputs
%% M1 : INDEPENDENT SENDER RECEIVER PAIRS
%% The following program has 5 processes: m1 (main), a & b (sender), c & d
%% (receiver). Run with test(m1).
%% main() ->
%% Parent = self(),
%% Rec1 = spawn(fun() -> receiver(Parent) end),
%% Rec2 = spawn(fun() -> receiver(Parent) end),
%% Snd1 = spawn(fun() -> sender(Rec1) end),
%% Snd2 = spawn(fun() -> sender(Rec2) end),
%% receive
%% ok ->
%% receive
%% ok -> done
%% end
%% end.
%% sender(Pid) ->
%% Pid ! ok.
%% receiver(Parent) ->
%% receive
%% ok -> Parent ! ok
%% end.
-ifdef(STATS).
-define(stats_start, put(interleavings, 0)).
-define(stats_report, io:format("Interleavings: ~p\n", [get(interleavings)])).
-define(stats_inc, begin
I = get(interleavings) + 1,
put(interleavings, I)
end).
-else.
-define(stats_start, ok).
-define(stats_report, ok).
-define(stats_inc, ok).
-endif.
-ifdef(STACK).
-define(show_stack(Trace), io:format("~p\n",[get_stack(Trace)])).
get_stack(Trace) ->
get_stack(Trace, []).
get_stack([], Acc) -> Acc;
get_stack([#state{last = P}|Rest], Acc) -> get_stack(Rest, [P|Acc]).
-else.
-define(show_stack(_Trace), ok).
-endif.
test(M) ->
InitPStates = dict:store(M, new_pstate(M), dict:new()),
?stats_start,
Trace = init_trace(InitPStates),
explore(Trace, new_clock_vector_dict()),
?stats_report.
new_pstate(P) -> #pstate{commands = p(P)}.
init_trace(InitPStates) -> [#state{i = 0, last = init, pstates = InitPStates}].
new_clock_vector_dict() -> dict:new().
p(m1) ->
[{spawn, c},
{spawn, d},
{spawn, a},
{spawn, b},
rec,
rec,
exit];
p(a) ->
[{send, c},
exit];
p(b) ->
[{send, d},
exit];
p(c) ->
[rec,
{send, m1},
exit];
p(d) ->
[rec,
{send, m1},
exit];
p(m2) ->
[{spawn, x},
{spawn, y},
{spawn, z},
{spawn, w},
{send, y},
exit];
p(x) ->
[rec,
{send,y},
exit];
p(y) ->
[rec,
rec,
exit];
p(z) ->
[rec,
{send,x},
exit];
p(w) ->
[{send,z},
exit].
%%------------------------------------------------------------------------------
do_command(#pstate{commands = [Command|Rest]} = PState) ->
{Command, PState#pstate{commands = Rest}}.
inc_mail(#pstate{mailbox = Mailbox} = PState) ->
PState#pstate{mailbox = Mailbox + 1}.
dec_mail(#pstate{mailbox = Mailbox} = PState) ->
PState#pstate{mailbox = Mailbox - 1}.
is_p_enabled(#pstate{commands = [Command|_], mailbox = Mailbox}) ->
Value =
case Command of
exit -> true;
{spawn, _Q} -> true;
{send, _Q} -> true;
rec -> Mailbox > 0
end,
case Value of
true -> {true, Command};
false -> false
end;
is_p_enabled(_) -> false.
run(P, PStates) ->
PState = dict:fetch(P, PStates),
{Command, NextPState} = do_command(PState),
case Command of
{spawn, Q} ->
NewPStates0 = dict:store(Q, #pstate{commands = p(Q)}, PStates),
{Command, {ok, dict:store(P, NextPState, NewPStates0)}};
{send, Q} ->
QState = dict:fetch(Q, PStates),
NewPStates0 = dict:store(Q, inc_mail(QState), PStates),
{Command, {ok, dict:store(P, NextPState, NewPStates0)}};
rec ->
{Command, {ok, dict:store(P, dec_mail(NextPState), PStates)}};
exit ->
{Command, {ok, dict:store(P, NextPState, PStates)}}
end.
%%------------------------------------------------------------------------------
%% ---------------------------
%% Erlang dependency semantics
%% ---------------------------
dependent({ P1, _C1}, { P2, _C2}) when P1 =:= P2 -> true;
dependent({_P1, {send, P2}}, {_P3, {send, P4}}) when P2 =:= P4 -> true;
%dependent({_P1, {send, P2}}, { P3, rec}) when P2 =:= P3 -> true;
%dependent({ P1, rec}, {_P2, {send, P3}}) when P1 =:= P3 -> true;
dependent( _, _) -> false.
dependent2({ P1, _C1}, { P2, _C2}) when P1 =:= P2 -> true;
dependent2({_P1, {send, P2}}, {_P3, {send, P4}}) when P2 =:= P4 -> true;
dependent2({_P1, {send, P2}}, { P3, rec}) when P2 =:= P3 -> true;
dependent2({ P1, rec}, {_P2, {send, P3}}) when P1 =:= P3 -> true;
dependent2( _, _) -> false.
%%------------------------------------------------------------------------------
-define(breakpoint, case io:get_line("") of "q\n" -> throw(q); _ -> ok end).
-ifdef(STEPWISE).
-define(stepwise, ?breakpoint).
-else.
-define(stepwise, ok).
-endif.
-ifdef(DEBUG).
-define(debug(A, B), io:format(A, B), ?stepwise).
-define(debug_break(A, B), io:format(A, B), ?breakpoint).
-else.
-define(debug(_A, _B), ok).
-define(debug_break(_A, _B), ok).
-endif.
-define(debug(A), ?debug(A, [])).
explore(Trace, ClockMap) ->
?debug("Explore ~p:\n", [get_stack(Trace)]),
UpdatedTrace = add_old_backtracks(Trace, ClockMap),
FinalTrace =
case pick_random_enabled(Trace) of
none ->
%% TODO: Report Check for deadlocks
?show_stack(Trace),
?stats_inc,
UpdatedTrace;
{ok, P} ->
?debug("Picking ~p for new step.\n", [P]),
NewTrace = add_new_backtrack(P, UpdatedTrace),
explore_backtracks(NewTrace, ClockMap)
end,
remove_last(FinalTrace).
add_old_backtracks([#state{pstates=PStates}|_] = Trace, ClockMap) ->
Nexts = get_all_nexts(PStates),
?debug("Backtrack points: Forall processes: ~p\n", [Nexts]),
add_old_backtracks(Nexts, Trace, ClockMap).
get_all_nexts(PStates) ->
Fold =
fun(P, #pstate{commands = Commands}, Acc) ->
case Commands of
[] -> Acc;
[C|_] -> [{P,C}|Acc]
end
end,
dict:fold(Fold, [], PStates).
add_old_backtracks([], Trace, _ClockMap) ->
?debug("Done adding backtrack points\n"),
Trace;
add_old_backtracks([Command|Rest], Trace, ClockMap) ->
?debug(" ~p:\n",[Command]),
NewTrace = add_old_backtracks_for_p(Command, Trace, [], ClockMap),
add_old_backtracks(Rest, NewTrace, ClockMap).
add_old_backtracks_for_p(_Cmd1, [], Acc, _ClockMap) ->
lists:reverse(Acc);
add_old_backtracks_for_p({ProcNext, _} = Next, [StateI|Rest], Acc, ClockMap) ->
case StateI of
#state{i = I, last = {ProcSi, _} = Si} ->
Dependent = dependent(Next, Si),
Clock = lookup_clock_value(ProcSi, lookup_clock(ProcNext, ClockMap)),
?debug(" ~p: ~p (Dep: ~p C: ~p)\n",
[I, Si] ++ [Dependent] ++ [Clock]),
case Dependent andalso I > Clock of
false ->
add_old_backtracks_for_p(Next, Rest, [StateI|Acc], ClockMap);
true ->
?debug(" Dependent and i < Clock. Backtracking.\n"),
[#state{pstates = PStates, backtrack = Backtrack} = Spi|Rest2] = Rest,
?debug(" Old backtrack: ~p\n", [Backtrack]),
NewBacktrack =
add_from_E(ProcNext, PStates, [StateI|Acc], ClockMap, Backtrack),
?debug(" New backtrack: ~p\n", [NewBacktrack]),
lists:reverse(Acc, [StateI,Spi#state{backtrack = NewBacktrack}|Rest2])
end;
#state{i = 0, last = init} ->
add_old_backtracks_for_p(Next, Rest, [StateI|Acc], ClockMap)
end.
add_from_E(P, PStates, ForwardTrace, ClockMap, Backtrack) ->
Enabled = all_enabled(PStates),
case lists:member(P, Enabled) of
true ->
?debug(" Enabled.\n"),
ordsets:add_element(P, Backtrack);
false ->
?debug(" Not Enabled.\n"),
ClockVector = lookup_clock(P, ClockMap),
case find_one_from_E(P, ClockVector, Enabled, ForwardTrace) of
{true, Q} ->
?debug(" Q needs to happen: ~p\n", [Q]),
ordsets:add_element(Q, Backtrack);
false ->
?debug(" Adding all enabled: ~p\n", [Enabled]),
ordsets:union(Backtrack, ordsets:from_list(Enabled))
end
end.
find_one_from_E(_P, _ClockVector, _Enabled, []) -> false;
find_one_from_E(P, ClockVector, Enabled, [Sj|Rest]) ->
#state{i = J, last = _Sj = {ProcSj, _}} = Sj,
?debug(" ~p: ~p\n", [J, ProcSj]),
Satisfies =
case lists:member(ProcSj, Enabled) of
false ->
?debug(" Was not enabled\n"),
false;
true ->
ClockValue = lookup_clock_value(ProcSj, ClockVector),
?debug(" Clock is: ~p\n", [ClockValue]),
J =< ClockValue
end,
case Satisfies of
true ->
?debug(" Found ~p\n", [ProcSj]),
{true, ProcSj};
false -> find_one_from_E(P, ClockVector, Enabled, Rest)
end.
lookup_clock(PorS, ClockMap) ->
case dict:find(PorS, ClockMap) of
{ok, Clock} -> Clock;
error -> dict:new()
end.
lookup_clock_value(P, CV) ->
case dict:find(P, CV) of
{ok, Value} -> Value;
error -> 0
end.
pick_random_enabled([#state{pstates = PStates}|_]) ->
%% TODO: This is not really efficient
case all_enabled(PStates) of
[] -> none;
[P|_] -> {ok, P}
end.
all_enabled(PStates) ->
Fun =
fun(P, PState, Acc) ->
case is_p_enabled(PState) of
false -> Acc;
{true, _C} -> [P|Acc]
end
end,
dict:fold(Fun, [], PStates).
remove_last([_Last|Trace]) ->
%% TODO: Replay trace till previous step.
Trace.
add_new_backtrack(P, [#state{} = State|Trace]) ->
[State#state{backtrack = [P]}|Trace].
explore_backtracks(Trace, ClockMap) ->
case pick_unexplored(Trace) of
none ->
?debug("All backtracks explored.\n"),
Trace;
{ok, P, NewTrace} ->
?debug("Picking unexplored: ~p\n", [P]),
case let_run(P, NewTrace) of
{error, _Command, _Info} ->
%% TODO: Report Something crashed
%% TODO: Replay trace till previous step
explore_backtracks(NewTrace, ClockMap);
{ok, NewTrace2} ->
NewClockMap = update_clock_map(NewTrace2, ClockMap),
NewTrace3 = explore(NewTrace2, NewClockMap),
explore_backtracks(NewTrace3, ClockMap)
end
end.
pick_unexplored([State|Rest]) ->
#state{backtrack = Backtrack, done = Done} = State,
?debug("Back:~p\nDone:~p\n",[Backtrack, Done]),
case find_unique(Backtrack, Done) of
{ok, P} -> {ok, P, [State#state{done = ordsets:add_element(P, Done)}|Rest]};
none -> none
end.
find_unique([], _Set2) -> none;
find_unique([P|Set1], Set2) ->
case ordsets:is_element(P, Set2) of
true -> find_unique(Set1, Set2);
false -> {ok, P}
end.
let_run(P, [#state{i = N, pstates = PStates}|_] = Trace) ->
{Command, Result} = run(P, PStates),
case Result of
{ok, NewPStates} ->
NewState = #state{i = N+1, last = {P, Command}, pstates = NewPStates},
NewTrace = [NewState|Trace],
{ok, NewTrace};
{error, Info} ->
{error, Command, Info}
end.
update_clock_map([#state{i = N, last = {P, _C} = Command}|Trace], ClockMap) ->
CV = max_dependent(Command, Trace, ClockMap),
CV2 = dict:store(P, N, CV),
Ca = dict:store(P, CV2, ClockMap),
dict:store(N, CV2, Ca).
max_dependent(Command, Trace, ClockMap) ->
max_dependent(Command, Trace, ClockMap, dict:new()).
max_dependent(_Cmd, [], _ClockMap, Acc) -> Acc;
max_dependent(Cmd1, [#state{i = N, last = Cmd2}|Trace], ClockMap, Acc) ->
case dependent2(Cmd1, Cmd2) of
true ->
CI = lookup_clock(N, ClockMap),
Merger = fun(_Key, V1, V2) -> max(V1, V2) end,
NewAcc = dict:merge(Merger, CI, Acc),
max_dependent(Cmd1, Trace, ClockMap, NewAcc);
false ->
max_dependent(Cmd1, Trace, ClockMap, Acc)
end.
================================================
FILE: resources/how-to-release.md
================================================
# How to make a release
Here is how to prepare a new release of Concuerror
## Decide release number
Follow semantic versioning (link in CHANGELOG.md)
`RELEASE=0.42`
## Fix and commit release number in CHANGELOG.md
Format the UNRELEASED section in CHANGELOG.md
`## [0.42](https://github.com/parapluu/Concuerror/releases/tag/0.42) - 2042-11-20`
Then commit:
`git commit -m "Update CHANGELOG for release ${RELEASE}"`
The UNRELEASED section will be added back as the last step.
## Make the release tag
`git tag -a ${RELEASE} -m "Release ${RELEASE}" -s`
## Ensure you are logged in to Hex
`rebar3 hex user whoami`
If no info shown:
`rebar3 hex user auth`
## Push package to Hex
`rebar3 hex publish`
## Push tag to repository
`git push parapluu ${RELEASE}`
## Create release from tag
Copy the most recent section of the CHANGELOG as description and leave title empty
## Add a new UNRELEASED section in CHANGELOG.md
```
## [Unreleased](https://github.com/parapluu/Concuerror/tree/master)
### Added
### Removed
### Changed
### Fixed
```
================================================
FILE: resources/old_include/gen.hrl
================================================
%%%----------------------------------------------------------------------
%%% Copyright (c) 2011, Alkis Gotovos <el3ctrologos@hotmail.com>,
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% and Kostis Sagonas <kostis@cs.ntua.gr>.
%%% All rights reserved.
%%%
%%% This file is distributed under the Simplified BSD License.
%%% Details can be found in the LICENSE file.
%%%----------------------------------------------------------------------
%%% Authors : Alkis Gotovos <el3ctrologos@hotmail.com>
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% Description : General header file
%%%----------------------------------------------------------------------
%%%----------------------------------------------------------------------
%%% Definitions
%%%----------------------------------------------------------------------
%% Application name (atom and string).
-define(APP_ATOM, list_to_atom(?APP_STRING)).
%% Registered process names.
-define(RP_GUI, '_._gui').
-define(RP_GUI_ANALYSIS, '_._gui_analysis').
-define(RP_SCHED, '_._sched').
-define(RP_SCHED_SEND, ?RP_SCHED).
-define(RP_LID, '_._lid').
-define(RP_LID_SEND, ?RP_LID).
%% Named ets table names.
-define(NT_BLOCKED, '_._blocked').
-define(NT_ERROR, '_._error').
-define(NT_LID, '_._lid').
-define(NT_PID, '_._pid').
-define(NT_REF, '_._ref').
-define(NT_STATE1, '_._state1').
-define(NT_STATE2, '_._state2').
-define(NT_STATELEN, '_._state_len').
-define(NT_USED, '_._used').
-define(NT_TIMER, '_._timer').
-define(NT_INSTR_MODS, '_._instr_mods').
-define(NT_INSTR_BIFS, '_._instr_bifs').
-define(NT_INSTR_IGNORED, '_._instr_ignored').
-define(NT_INSTR, '_._instr_table').
-define(NT_OPTIONS, '_._conc_options').
%% Module containing replacement functions.
-define(REP_MOD, concuerror_rep).
%% Instrumented message atom.
-define(INSTR_MSG, '_._instr_msg').
%% Instrumented modules prefix.
-define(INSTR_PREFIX, "conc__").
%% Set-like data structure used in sched, lid and error modules.
-define(SETS, ordsets).
-define(SET_TYPE(X), [X]). %% XXX: bad -- ordsets does not export the type!
%% Default options
-define(DEFAULT_PREB, 2).
-define(DEFAULT_INCLUDE, []).
-define(DEFAULT_DEFINE, []).
-define(DEFAULT_VERBOSITY, 0).
%% Default export file.
-define(EXPORT_EXT, ".txt").
-define(EXPORT_FILE, "results" ++ ?EXPORT_EXT).
%% Internal error return code.
-define(RET_INTERNAL_ERROR, 1).
%% Host - Node names.
-define(NODE, atom_to_list(node())).
-define(HOST, lists:dropwhile(fun(E) -> E /= $@ end, ?NODE)).
%% 'About' message
-define(INFO_MSG,
"
Concuerror
A systematic testing tool for concurrent Erlang programs.
Version " ?VSN "
").
%% Debug macros.
-ifdef(COND_DEBUG).
-define(debug_start, put(debug, true)).
-define(debug_stop, erase(debug)).
-define(debug(S_, L_),
begin
case get(debug) of
true -> io:format(S_, L_);
_ -> ok
end
end).
-else.
-define(debug_start, ok).
-define(debug_stop, ok).
-endif.
-ifndef(COND_DEBUG).
-ifdef(DEBUG).
-define(debug(S_, L_), io:format(S_, L_)).
-else.
-define(debug(S_, L_), ok).
-endif. %DEBUG
-endif. %COND_DEBUG
-define(debug(S_), ?debug(S_,[])).
-define(DEBUG_DEPTH, 12).
================================================
FILE: resources/old_include/gui.hrl
================================================
%%%----------------------------------------------------------------------
%%% Copyright (c) 2011, Alkis Gotovos <el3ctrologos@hotmail.com>,
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% and Kostis Sagonas <kostis@cs.ntua.gr>.
%%% All rights reserved.
%%%
%%% This file is distributed under the Simplified BSD License.
%%% Details can be found in the LICENSE file.
%%%----------------------------------------------------------------------
%%% Authors : Alkis Gotovos <el3ctrologos@hotmail.com>
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% Description : GUI header file
%%%----------------------------------------------------------------------
%%%----------------------------------------------------------------------
%%% Definitions
%%%----------------------------------------------------------------------
%% Initial frame size.
-define(FRAME_SIZE_INIT, {1024, 768}).
%% Menu specification:
%% [{MenuName1, [MenuItem11, MenuItem12, ...]}, ...]
-define(MENU_SPEC,
[{"&File",
[[{id, ?SAVEAS}, {text, "&Save As...\tCtrl-S"},
{help, "Save analysis information to file."},
{label, ?SAVEAS_MENU_ITEM}],
[{id, ?wxID_SEPARATOR}, {kind, ?wxITEM_SEPARATOR}],
[{id, ?EXIT}, {help, "Quit Concuerror."}]]},
{"&Edit",
[[{id, ?PREFS}, {text, "&Preferences...\tCtrl-P"},
{help, "Edit Concuerror preferences."}]]},
{"&Module",
[[{id, ?ADD}, {text, "&Add...\tCtrl-A"},
{help, "Add an existing erlang module."}],
[{id, ?REMOVE}, {text, "&Remove\tCtrl-R"},
{help, "Remove selected module."}],
[{id, ?wxID_SEPARATOR}, {kind, ?wxITEM_SEPARATOR}],
[{id, ?CLEAR}, {text, "&Clear\tCtrl-C"},
{help, "Clear module list."}],
[{id, ?REFRESH}, {text, "Re&fresh\tF5"},
{help, "Refresh selected module (reload file from disk)."}]]},
{"&Run",
[[{id, ?ANALYZE}, {text, "Ana&lyze\tCtrl-L"},
{help, "Analyze selected function."},
{label, ?ANALYZE_MENU_ITEM}],
[{id, ?STOP}, {text, "Sto&p\tCtrl-P"},
{help, "Stop analysis of selected function."},
{label, ?STOP_MENU_ITEM}]]},
{"&View",
[[{id, ?wxID_ANY}, {text, "Source viewer color theme"},
{help, "Select a color theme for the source viewer."},
{sub,
[[{id, ?THEME_LIGHT}, {text, "Light theme"},
{kind, ?wxITEM_RADIO}],
[{id, ?THEME_DARK}, {text, "Dark theme"},
{kind, ?wxITEM_RADIO}]]}
]]},
{"&Help",
[[{id, ?ABOUT}, {text, "&About"},
{help, "Show project info."}]]}
]).
%% GUI component definitions
-define(ABOUT, ?wxID_ABOUT).
-define(ADD, ?wxID_ADD).
-define(CLEAR, ?wxID_CLEAR).
-define(REMOVE, ?wxID_REMOVE).
-define(SEPARATOR, ?wxID_SEPARATOR).
-define(EXIT, ?wxID_EXIT).
-define(SAVEAS, ?wxID_SAVEAS).
-define(REFRESH, ?wxID_REFRESH).
-define(ANAL_STOP_SIZER, 500).
-define(ANALYZE, 501).
-define(ANALYZE_GAUGE, 502).
-define(ANALYZE_MENU_ITEM, 503).
-define(ERROR_ILEAVE_SPLITTER, 504).
-define(ERROR_LIST, 505).
-define(ERROR_TEXT, 506).
-define(SAVEAS_MENU_ITEM, 508).
-define(FRAME, 509).
-define(FUNCTION_LIST, 510).
-define(GRAPH_PANEL, 511).
-define(ILEAVE_LIST, 512).
-define(LOG_NOTEBOOK, 515).
-define(LOG_TEXT, 516).
-define(MOD_FUN_SPLITTER, 517).
-define(MODULE_LIST, 518).
-define(NOTEBOOK, 519).
-define(NOTEBOOK_SPLITTER, 520).
-define(PREB_BOUND_SPIN, 521).
-define(PREB_ENABLED_CBOX, 522).
-define(PREFS, 523).
-define(PROC_TEXT, 524).
-define(SCR_GRAPH, 526).
-define(SOURCE_TEXT, 527).
-define(STATIC_BMP, 528).
-define(STATUS_BAR, 529).
-define(STOP, 530).
-define(STOP_GAUGE, 531).
-define(STOP_MENU_ITEM, 532).
-define(THEME_DARK, 533).
-define(THEME_LIGHT, 534).
-define(TOP_SPLITTER, 535).
%% Splitter init-sizes
-define(SPLITTER_INIT, [{?TOP_SPLITTER, 300},
{?MOD_FUN_SPLITTER, 300},
{?NOTEBOOK_SPLITTER, 530},
{?ERROR_ILEAVE_SPLITTER, 250}]).
%% Splitter min-sizes
-define(MIN_TOP, 250).
-define(MIN_MOD_FUN, 50).
-define(MIN_NOTEBOOK, 50).
-define(MIN_ERROR_ILEAVE, 50).
%% Splitter gravities
-define(GRAV_TOP, 0.0).
-define(GRAV_MOD_FUN, 0.3).
-define(GRAV_NOTEBOOK, 0.8).
-define(GRAV_ERROR_ILEAVE, 0.2).
%% Preferences related definitions
-define(PREF_PREB_ENABLED, 560).
-define(PREF_PREB_BOUND, 561).
-define(PREF_INCLUDE, 562).
-define(PREF_DEFINE, 563).
%% Analysis Result definitions
-define(ANALYSIS_RET, 564).
%% Other definitions
-define(FILE_PATH, 565).
%% Erlang keywords
-define(KEYWORDS, "after begin case try cond catch andalso orelse end fun "
"if let of query receive when bnot not div rem band and "
"bor bxor bsl bsr or xor").
%% Source viewer styles
-define(SOURCE_BG_DARK, {63, 63, 63}).
-define(SOURCE_FG_DARK, {220, 220, 204}).
%% -define(SOURCE_FG_DARK, {204, 220, 220}).
-define(SOURCE_STYLES_DARK,
[{?wxSTC_ERLANG_ATOM, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_CHARACTER, {204, 147, 147}, normal},
{?wxSTC_ERLANG_COMMENT, {127, 159, 127}, normal},
{?wxSTC_ERLANG_DEFAULT, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_FUNCTION_NAME, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_KEYWORD, {240, 223, 175}, bold},
{?wxSTC_ERLANG_MACRO, {255, 207, 175}, normal},
{?wxSTC_ERLANG_NODE_NAME, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_NUMBER, {140, 208, 211}, normal},
{?wxSTC_ERLANG_OPERATOR, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_RECORD, {232, 147, 147}, normal},
{?wxSTC_ERLANG_SEPARATOR, ?SOURCE_FG_DARK, normal},
{?wxSTC_ERLANG_STRING, {204, 147, 147}, normal},
{?wxSTC_ERLANG_VARIABLE, {239, 239, 175}, bold},
{?wxSTC_ERLANG_UNKNOWN, {255, 0, 0}, normal}]).
-define(SOURCE_BG_LIGHT, {255, 255, 255}).
-define(SOURCE_FG_LIGHT, {30, 30, 30}).
-define(SOURCE_STYLES_LIGHT,
[{?wxSTC_ERLANG_ATOM, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_CHARACTER, {120, 190, 120}, normal},
{?wxSTC_ERLANG_COMMENT, {20, 140, 20}, normal},
{?wxSTC_ERLANG_DEFAULT, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_FUNCTION_NAME, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_KEYWORD, {140, 40, 170}, bold},
{?wxSTC_ERLANG_MACRO, {180, 40, 40}, normal},
{?wxSTC_ERLANG_NODE_NAME, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_NUMBER, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_OPERATOR, {70, 70, 70}, normal},
{?wxSTC_ERLANG_RECORD, {150, 140, 40}, normal},
{?wxSTC_ERLANG_SEPARATOR, ?SOURCE_FG_LIGHT, normal},
{?wxSTC_ERLANG_STRING, {50, 50, 200}, normal},
{?wxSTC_ERLANG_VARIABLE, {20, 120, 140}, bold},
{?wxSTC_ERLANG_UNKNOWN, {255, 0, 0}, normal}]).
================================================
FILE: resources/old_include/instr.hrl
================================================
%%%----------------------------------------------------------------------
%%% Copyright (c) 2013, Alkis Gotovos <el3ctrologos@hotmail.com>,
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% and Kostis Sagonas <kostis@cs.ntua.gr>.
%%% All rights reserved.
%%%
%%% This file is distributed under the Simplified BSD License.
%%% Details can be found in the LICENSE file.
%%%----------------------------------------------------------------------
%%% Authors : Ilias Tsitsimpis <i.tsitsimpis@gmail.com>
%%% Description : Instrumentation header file
%%%----------------------------------------------------------------------
%%%----------------------------------------------------------------------
%%% Definitions
%%%----------------------------------------------------------------------
%% List of attributes that should be stripped.
-define(ATTR_STRIP, [type, spec, opaque, export_type, import_type, callback]).
%% Instrumented auto-imported functions of 'erlang' module.
-define(INSTR_ERL_FUN,
[{demonitor, 1},
{demonitor, 2},
{exit, 2},
{halt, 0},
{halt, 1},
{is_process_alive, 1},
{link, 1},
{monitor, 2},
{process_flag, 2},
{register, 2},
{spawn, 1},
{spawn, 3},
{spawn_link, 1},
{spawn_link, 3},
{spawn_monitor, 1},
{spawn_monitor, 3},
{spawn_opt, 2},
{spawn_opt, 4},
{unlink, 1},
{unregister, 1},
{port_command, 2},
{port_command, 3},
{port_control, 3},
{apply, 3},
{whereis, 1}]).
%% Instrumented functions called as erlang:FUNCTION.
-define(INSTR_ERL_MOD_FUN,
[{erlang, send, 2},
{erlang, send, 3},
{erlang, send_after, 3},
{erlang, start_timer, 3}] ++
[{erlang, F, A} || {F, A} <- ?INSTR_ERL_FUN]).
%% Instrumented functions from ets module.
-define(INSTR_ETS_FUN,
[{ets, insert_new, 2},
{ets, lookup, 2},
{ets, select_delete, 2},
{ets, insert, 2},
{ets, delete, 1},
{ets, delete, 2},
{ets, filter, 3},
{ets, match, 2},
{ets, match, 3},
{ets, match_object, 2},
{ets, match_object, 3},
{ets, match_delete, 2},
{ets, new, 2},
{ets, info, 1},
{ets, info, 2},
{ets, foldl, 3}]).
%% Instrumented mod:fun.
-define(INSTR_MOD_FUN, ?INSTR_ERL_MOD_FUN ++ ?INSTR_ETS_FUN).
%% Key in ?NT_INSTR to use for temp directory.
-define(INSTR_TEMP_DIR, '_._instr_temp_dir').
%% Key in ?NT_INSTR to use for `fail-uninstrumented' flag.
-define(FAIL_BB, '_._instr_fail_bb').
%% -------------------------------------------------------------------
%% BIFs (taken from file `otp/erts/emulator/beam/bif.tab'
%% We don't care about `erlang' and `ets' BIFS as
%% we don't rename them anyway.
-define(PREDEF_BIFS,
[% Bifs in `math' module
{math, cos, 1},
{math, cosh, 1},
{math, sin, 1},
{math, sinh, 1},
{math, tan, 1},
{math, tanh, 1},
{math, acos, 1},
{math, acosh, 1},
{math, asin, 1},
{math, asinh, 1},
{math, atan, 1},
{math, atanh, 1},
{math, erf, 1},
{math, erfc, 1},
{math, exp, 1},
{math, log, 1},
{math, log10, 1},
{math, sqrt, 1},
{math, atan2, 2},
{math, pow, 2},
% Bifs in `os' module
{os, putenv, 2},
{os, getenv, 0},
{os, getenv, 1},
{os, getpid, 0},
{os, timestamp, 0},
% Bifs in the `re' module
{re, compile, 1},
{re, compile, 2},
{re, run, 2},
{re, run, 3},
% Bifs in the `lists' module
{lists, member, 2},
{lists, reverse, 2},
{lists, keymember, 3},
{lists, keysearch, 3},
{lists, keyfind, 3},
% Bifs for `debugging'
{erts_debug, disassemble, 1},
{erts_debug, breakpoint, 2},
{erts_debug, same, 2},
{erts_debug, flat_size, 1},
{erts_debug, get_internal_state, 1},
{erts_debug, set_internal_state, 2},
{erts_debug, display, 1},
{erts_debug, dist_ext_to_term, 2},
{erts_debug, instructions, 0},
% `Monitor testing' bif's
{erts_debug, dump_monitors, 1},
{erts_debug, dump_links, 1},
% `Lock counter' bif's
{erts_debug, lock_counters, 1},
% New Bifs in `R8'
{code, get_chunk, 2},
{code, module_md5, 1},
{code, make_stub_module, 3},
{code, is_module_native, 1},
% New Bifs in `R10B'
{string, to_integer, 1},
{string, to_float, 1},
% New Bifs in `R12B-5'
{unicode, characters_to_binary, 2},
{unicode, characters_to_list, 2},
{unicode, bin_is_7bit, 1},
% New Bifs in `R13B-1'
{net_kernel, dflag_unicode_io, 1},
% The `binary' match bifs
{binary, compile_pattern, 1},
{binary, match, 2},
{binary, match, 3},
{binary, matches, 2},
{binary, matches, 3},
{binary, longest_common_prefix, 1},
{binary, longest_common_suffix, 1},
{binary, first, 1},
{binary, last, 1},
{binary, at, 2},
{binary, part, 2},
{binary, part, 3},
{binary, bin_to_list, 1},
{binary, bin_to_list, 2},
{binary, bin_to_list, 3},
{binary, list_to_bin, 1},
{binary, copy, 1},
{binary, copy, 2},
{binary, referenced_byte_size, 1},
{binary, encode_unsigned, 1},
{binary, encode_unsigned, 2},
{binary, decode_unsigned, 1},
{binary, decode_unsigned, 2},
% Helpers for unicode filenames
{file, native_name_encoding, 0}
]).
================================================
FILE: resources/old_source/LICENSE
================================================
Copyright (c) 2011, Alkis Gotovos <el3ctrologos@hotmail.com>,
Maria Christakis <mchrista@softlab.ntua.gr> and
Kostis Sagonas <kostis@cs.ntua.gr>.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: resources/old_source/concuerror.erl
================================================
%%%----------------------------------------------------------------------
%%% Copyright (c) 2012, Alkis Gotovos <el3ctrologos@hotmail.com>,
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% and Kostis Sagonas <kostis@cs.ntua.gr>.
%%% All rights reserved.
%%%
%%% This file is distributed under the Simplified BSD License.
%%% Details can be found in the LICENSE file.
%%%----------------------------------------------------------------------
%%% Authors : Ilias Tsitsimpis <iliastsi@hotmail.com>
%%% Description : Command Line Interface
%%%----------------------------------------------------------------------
-module(concuerror).
%% UI exports.
-export([gui/1, cli/0, analyze/1, export/2, stop/0, stop/1]).
%% Log server callback exports.
-export([init/1, terminate/2, handle_event/2]).
-export_type([options/0]).
-include("gen.hrl").
%%%----------------------------------------------------------------------
%%% Debug
%%%----------------------------------------------------------------------
%%-define(TTY, true).
-ifdef(TTY).
-define(tty(), ok).
-else.
-define(tty(), error_logger:tty(false)).
-endif.
%%%----------------------------------------------------------------------
%%% Types
%%%----------------------------------------------------------------------
-type analysis_ret() ::
concuerror_sched:analysis_ret()
| {'error', 'arguments', string()}.
%% Command line options
-type option() ::
{'target', concuerror_sched:analysis_target()}
| {'files', [file:filename()]}
| {'output', file:filename()}
| {'include', [file:name()]}
| {'define', concuerror_instr:macros()}
| {'dpor', 'full' | 'source' | 'classic'}
| {'noprogress'}
| {'quiet'}
| {'preb', concuerror_sched:bound()}
| {'gui'}
| {'verbose', non_neg_integer()}
| {'keep_temp'}
| {'show_output'}
| {'fail_uninstrumented'}
| {'wait_messages'}
| {'ignore_timeout', pos_integer()}
| {'ignore', [module()]}
| {'app_controller'}
| {'help'}.
-type options() :: [option()].
%%%----------------------------------------------------------------------
%%% UI functions
%%%----------------------------------------------------------------------
%% @spec stop() -> ok
%% @doc: Stop the Concuerror analysis
-spec stop() -> ok.
stop() ->
try ?RP_SCHED ! stop_analysis
catch
error:badarg ->
init:stop()
end,
ok.
%% @spec stop_node([string(),...]) -> ok
%% @doc: Stop the Concuerror analysis
-spec stop([string(),...]) -> ok.
stop([Name]) ->
%% Disable error logging messages.
?tty(),
Node = list_to_atom(Name ++ ?HOST),
case rpc:call(Node, ?MODULE, stop, []) of
{badrpc, _Reason} ->
%% Retry
stop([Name]);
_Res ->
ok
end.
%% @spec gui(options()) -> 'true'
%% @doc: Start the Concuerror GUI.
-spec gui(options()) -> 'true'.
gui(Options) ->
%% Disable error logging messages.
?tty(),
concuerror_gui:start(Options).
%% @spec cli() -> 'true'
%% @doc: Parse the command line arguments and start Concuerror.
-spec cli() -> 'true'.
cli() ->
%% Disable error logging messages.
?tty(),
%% First get the command line options
Args = init:get_arguments(),
%% There should be no plain_arguments
case init:get_plain_arguments() of
[PlArg|_] ->
io:format("~s: unrecognised argument: ~s\n", [?APP_STRING, PlArg]);
[] ->
case parse(Args, [{'verbose', 0}]) of
{'error', 'arguments', Msg1} ->
io:format("~s: ~s\n", [?APP_STRING, Msg1]);
Opts -> cliAux(Opts)
end
end.
cliAux(Options) ->
%% Initialize timer table.
concuerror_util:timer_init(),
%% Start the log manager.
_ = concuerror_log:start(),
%% Create table to save options
?NT_OPTIONS = ets:new(?NT_OPTIONS, [named_table, public, set]),
ets:insert(?NT_OPTIONS, Options),
%% Handle options
case lists:keyfind('gui', 1, Options) of
{'gui'} -> gui(Options);
false ->
%% Attach the event handler below.
case lists:keyfind('quiet', 1, Options) of
false ->
_ = concuerror_log:attach(?MODULE, Options),
ok;
{'quiet'} -> ok
end,
%% Run analysis
case analyzeAux(Options) of
{'error', 'arguments', Msg1} ->
io:format("~s: ~s\n", [?APP_STRING, Msg1]);
Result ->
%% Set output file
Output =
case lists:keyfind(output, 1, Options) of
{output, O} -> O;
false -> ?EXPORT_FILE
end,
concuerror_log:log(0,
"\nWriting output to file ~s... ", [Output]),
case export(Result, Output) of
{'error', Msg2} ->
concuerror_log:log(0,
"~s\n", [file:format_error(Msg2)]);
ok ->
concuerror_log:log(0, "done\n")
end
end
end,
%% Remove options table
ets:delete(?NT_OPTIONS),
%% Stop event handler
concuerror_log:stop(),
%% Destroy timer table.
concuerror_util:timer_destroy(),
'true'.
%% Parse command line arguments
parse([], Options) ->
Options;
parse([{Opt, Param} | Args], Options) ->
case atom_to_list(Opt) of
T when T=:="t"; T=:="-target" ->
case Param of
[Module,Func|Pars] ->
AtomModule = erlang:list_to_atom(Module),
AtomFunc = erlang:list_to_atom(Func),
case validateTerms(Pars, []) of
{'error',_,_}=Error -> Error;
AtomParams ->
Target = {AtomModule, AtomFunc, AtomParams},
NewOptions = lists:keystore(target, 1,
Options, {target, Target}),
parse(Args, NewOptions)
end;
%% Run Eunit tests for specific module
[Module] ->
AtomModule = ?REP_MOD,
AtomFunc = 'rep_eunit',
Pars = [Module],
case validateTerms(Pars, []) of
{'error',_,_}=Error -> Error;
AtomParams ->
Target = {AtomModule, AtomFunc, AtomParams},
NewOptions = lists:keystore(target, 1,
Options, {target, Target}),
NewArgs = [{'D',["TEST"]} | Args],
parse(NewArgs, NewOptions)
end;
_Other -> wrongArgument('number', Opt)
end;
F when F=:="f"; F=:="-files" ->
case Param of
[] -> wrongArgument('number', Opt);
Files ->
NewOptions = keyAppend(files, 1, Options, Files),
parse(Args, NewOptions)
end;
O when O=:="o"; O=:="-output" ->
case Param of
[File] ->
NewOptions = lists:keystore(output, 1,
Options, {output, File}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"I" ->
case Param of
[Par] ->
NewOptions = keyAppend('include', 1,
Options, [Par]),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"I" ++ Include ->
case Param of
[] -> parse([{'I', [Include]} | Args], Options);
_Other -> wrongArgument('number', Opt)
end;
"D" ->
case Param of
[Par] ->
case string:tokens(Par, "=") of
[Name, Term] ->
AtomName = erlang:list_to_atom(Name),
case validateTerms([Term], []) of
{'error',_,_}=Error -> Error;
[AtomTerm] ->
NewOptions = keyAppend('define', 1,
Options, [{AtomName, AtomTerm}]),
parse(Args, NewOptions)
end;
[Name] ->
AtomName = erlang:list_to_atom(Name),
case validateTerms(["true"], []) of
{'error',_,_}=Error -> Error;
[AtomTerm] ->
NewOptions = keyAppend('define', 1,
Options, [{AtomName, AtomTerm}]),
parse(Args, NewOptions)
end;
_Other -> wrongArgument('type', Opt)
end;
_Other -> wrongArgument('number', Opt)
end;
"D" ++ Define ->
case Param of
[] -> parse([{'D', [Define]} | Args], Options);
_Other -> wrongArgument('number', Opt)
end;
"-noprogress" ->
case Param of
[] ->
NewOptions = lists:keystore(noprogress, 1,
Options, {noprogress}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
Q when Q=:="q"; Q=:="-quiet" ->
case Param of
[] ->
NewOptions = lists:keystore(quiet, 1,
Options, {quiet}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
P when P=:="p"; P=:="-preb" ->
case Param of
[Preb] ->
case string:to_integer(Preb) of
{I, []} when I>=0 ->
NewOptions = lists:keystore(preb, 1, Options,
{preb, I}),
parse(Args, NewOptions);
_ when Preb=:="inf"; Preb=:="off" ->
NewOptions = lists:keystore(preb, 1, Options,
{preb, inf}),
parse(Args, NewOptions);
_Other -> wrongArgument('type', Opt)
end;
_Other -> wrongArgument('number', Opt)
end;
"-gui" ->
case Param of
[] ->
NewOptions = lists:keystore(gui, 1,
Options, {gui}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"v" ->
case Param of
[] ->
NewOptions = keyIncrease('verbose', 1, Options),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"-keep-tmp-files" ->
case Param of
[] ->
NewOptions = lists:keystore('keep_temp', 1,
Options, {'keep_temp'}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"-fail-uninstrumented" ->
case Param of
[] ->
NewOptions = lists:keystore('fail_uninstrumented', 1,
Options, {'fail_uninstrumented'}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"-app-controller" ->
case Param of
[] ->
NewOptions = lists:keystore('app_controller', 1,
Options, {'app_controller'}),
parse(Args, NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"-ignore" ->
case Param of
[] -> wrongArgument('number', Opt);
Ignores ->
AtomIgns = [list_to_atom(Ign) || Ign <- Ignores],
NewOptions = keyAppend('ignore', 1, Options, AtomIgns),
parse(Args, NewOptions)
end;
"-show-output" ->
case Param of
[] ->
NewOptions = lists:keystore('show_output', 1,
Options, {'show_output'}),
%% Disable progress
parse([{'-noprogress', []} | Args], NewOptions);
_Other -> wrongArgument('number', Opt)
end;
"-wait-messages" ->
case Param of
[] ->
NewOptions = lists:keystore('wait_messages', 1,
Options, {'wait_messages'}),
parse(Args, NewOptions);
_Ohter -> wrongArgument('number', Opt)
end;
T when T =:= "T"; T =:= "-ignore-timeout" ->
case Param of
[Timeout] ->
case string:to_integer(Timeout) of
{Timeout_Int, []} when Timeout_Int > 0 ->
NewOptions = lists:keystore('ignore_timeout',
1, Options, {'ignore_timeout', Timeout_Int}),
parse(Args, NewOptions);
_Other -> wrongArgument('type', Opt)
end;
_Other -> wrongArgument('number', Opt)
end;
"-help" ->
help(),
erlang:halt();
DPOR when
DPOR =:= "-dpor";
DPOR =:= "-dpor_optimal";
DPOR =:= "-dpor_source";
DPOR =:= "-dpor_classic" ->
Flavor =
case DPOR of
"-dpor" -> full;
"-dpor_optimal" -> full;
"-dpor_source" -> source;
"-dpor_classic" -> classic
end,
case lists:keysearch(dpor, 1, Options) of
false ->
NewOptions = [{dpor, Flavor}|Options],
parse(Args, NewOptions);
_ ->
Msg = "multiple DPOR algorithms specified",
{'error', 'arguments', Msg}
end;
EF when EF=:="root"; EF=:="progname"; EF=:="home"; EF=:="smp";
EF=:="noshell"; EF=:="noinput"; EF=:="sname"; EF=:="pa";
EF=:="cookie" ->
%% erl flag (ignore it)
parse(Args, Options);
Other ->
Msg = io_lib:format("unrecognised concuerror flag: -~s", [Other]),
{'error', 'arguments', Msg}
end.
%% Validate user provided terms.
validateTerms([], Terms) ->
lists:reverse(Terms);
validateTerms([String|Strings], Terms) ->
case erl_scan:string(String ++ ".") of
{ok, T, _} ->
case erl_parse:parse_term(T) of
{ok, Term} -> validateTerms(Strings, [Term|Terms]);
{error, {_, _, Info}} ->
Msg1 = io_lib:format("arg ~s - ~s", [String, Info]),
{'error', 'arguments', Msg1}
end;
{error, {_, _, Info}, _} ->
Msg2 = io_lib:format("info ~s", [Info]),
{'error', 'arguments', Msg2}
end.
keyAppend(Key, Pos, TupleList, Value) ->
case lists:keytake(Key, Pos, TupleList) of
{value, {Key, PrevValue}, TupleList2} ->
[{Key, Value ++ PrevValue} | TupleList2];
false ->
[{Key, Value} | TupleList]
end.
keyIncrease(Key, Pos, TupleList) ->
case lists:keytake(Key, Pos, TupleList) of
{value, {Key, PrevValue}, TupleList2} ->
[{Key, PrevValue+1} | TupleList2];
false ->
[{Key, ?DEFAULT_VERBOSITY + 1} | TupleList]
end.
wrongArgument('number', Option) ->
Msg = io_lib:format("wrong number of arguments for option -~s", [Option]),
{'error', 'arguments', Msg};
wrongArgument('type', Option) ->
Msg = io_lib:format("wrong type of argument for option -~s", [Option]),
{'error', 'arguments', Msg}.
help() ->
io:format(
?INFO_MSG
"\n"
"usage: concuerror [<args>]\n"
"Arguments:\n"
" -t|--target module Run eunit tests for this module\n"
" -t|--target module function [args]\n"
" Specify the function to execute\n"
" -f|--files modules Specify the files (modules) to instrument\n"
" -o|--output file Specify the output file (default results.txt)\n"
" -p|--preb number|inf Set preemption bound (default is 2)\n"
" -I include_dir Pass the include_dir to concuerror\n"
" -D name=value Define a macro\n"
" --noprogress Disable progress bar\n"
" -q|--quiet Disable logging (implies --noprogress)\n"
" -v Verbose [use twice to be more verbose]\n"
" --keep-tmp-files Retain all intermediate temporary files\n"
" --fail-uninstrumented Fail if there are uninstrumented modules\n"
" --ignore modules It is OK for these modules to be uninstrumented\n"
" --show-output Allow program under test to print to stdout\n"
" --wait-messages Wait for uninstrumented messages to arrive\n"
" --app-controller Start an (instrumented) application controller\n"
" -T|--ignore-timeout bound\n"
" Treat big after Timeouts as infinity timeouts\n"
" --gui Run concuerror with a graphical interface\n"
" --help Show this help message\n"
"\n"
" DPOR algorithms:\n"
" --dpor|--dpor_optimal Enables the optimal DPOR algorithm\n"
" --dpor_classic Enables the classic DPOR algorithm\n"
" --dpor_source Enables the DPOR algorithm based on source sets\n"
"\n"
"Examples:\n"
" concuerror -DVSN=\\\"1.0\\\" --target foo bar arg1 arg2 "
"--files \"foo.erl\" -o out.txt\n"
" concuerror --gui -I./include --files foo.erl --preb inf\n\n").
%%%----------------------------------------------------------------------
%%% Analyze Commnad
%%%----------------------------------------------------------------------
%% @spec analyze(options()) -> 'true'
%% @doc: Run Concuerror analysis with the given options.
-spec analyze(options()) -> analysis_ret().
analyze(Options) ->
%% Disable error logging messages.
?tty(),
%% Start the log manager.
_ = concuerror_log:start(),
Res = analyzeAux(Options),
%% Stop event handler
concuerror_log:stop(),
Res.
analyzeAux(Options) ->
%% Get target
Result =
case lists:keyfind(target, 1, Options) of
false ->
Msg1 = "no target specified",
{'error', 'arguments', Msg1};
{target, Target} ->
%% Get input files
case lists:keyfind(files, 1, Options) of
false ->
Msg2 = "no input files specified",
{'error', 'arguments', Msg2};
{files, Files} ->
%% Start the analysis
concuerror_sched:analyze(Target, Files, Options)
end
end,
%% Return result
Result.
%%%----------------------------------------------------------------------
%%% Export Analysis results into a file
%%%----------------------------------------------------------------------
%% @spec export(concuerror_sched:analysis_ret(), file:filename()) ->
%% 'ok' | {'error', file:posix() | badarg | system_limit}
%% @doc: Export the analysis results into a text file.
-spec export(concuerror_sched:analysis_ret(), file:filename()) ->
'ok' | {'error', file:posix() | badarg | system_limit | terminated}.
export(Results, File) ->
case file:open(File, ['write']) of
{ok, IoDevice} ->
case exportAux(Results, IoDevice) of
ok -> file:close(IoDevice);
Error -> Error
end;
Error -> Error
end.
exportAux({'ok', {_Target, RunCount, SBlocked}}, IoDevice) ->
Msg = io_lib:format("Checked ~w interleaving(s). No errors found.\n",
[RunCount]),
SBMsg =
case SBlocked of
0 -> "";
_ -> io_lib:format(" Encountered ~w sleep-set blocked trace(s).\n",
[SBlocked])
end,
file:write(IoDevice, Msg++SBMsg);
exportAux({error, instr,
{_Target, _RunCount, _SBlocked}}, IoDevice) ->
Msg = "Instrumentation error.\n",
file:write(IoDevice, Msg);
exportAux({error, analysis,
{_Target, RunCount, SBlocked}, Tickets}, IoDevice) ->
TickLen = length(Tickets),
Msg = io_lib:format("Checked ~w interleaving(s). ~w errors found.\n",
[RunCount, TickLen]),
SBMsg =
case SBlocked of
0 -> "\n";
_ -> io_lib:format(
" Encountered ~w sleep-set blocked trace(s).\n\n",
[SBlocked])
end,
case file:write(IoDevice, Msg++SBMsg) of
ok ->
case lists:foldl(fun writeDetails/2, {1, IoDevice},
concuerror_ticket:sort(Tickets)) of
{'error', _Reason}=Error -> Error;
_Ok -> ok
end;
Error -> Error
end.
%% Write details about each ticket
writeDetails(_Ticket, {'error', _Reason}=Error) ->
Error;
writeDetails(Ticket, {Count, IoDevice}) ->
Error = concuerror_ticket:get_error(Ticket),
Description = io_lib:format("~p\n~s\n",
[Count, concuerror_error:long(Error)]),
Details = [" " ++ M ++ "\n"
|| M <- concuerror_ticket:details_to_strings(Ticket)],
Msg = lists:flatten([Description | Details]),
case file:write(IoDevice, Msg ++ "\n\n") of
ok -> {Count+1, IoDevice};
WriteError -> WriteError
end.
%%%----------------------------------------------------------------------
%%% Log event handler callback functions
%%%----------------------------------------------------------------------
-type state() :: {non_neg_integer(), %% Verbose level
concuerror_util:progress() | 'noprogress'}.
-spec init(term()) -> {'ok', state()}.
%% @doc: Initialize the event handler.
init(Options) ->
Progress =
case lists:keyfind(noprogress, 1, Options) of
{noprogress} -> noprogress;
false -> concuerror_util:init_state()
end,
Verbosity =
case lists:keyfind('verbose', 1, Options) of
{'verbose', V} -> V;
false -> 0
end,
{ok, {Verbosity, Progress}}.
-spec terminate(term(), state()) -> 'ok'.
terminate(_Reason, {_Verb, 'noprogress'}) ->
ok;
terminate(_Reason, {_Verb, {_RunCnt, _Errors, _Elapsed, Timer}}) ->
concuerror_util:timer_stop(Timer),
ok.
-spec handle_event(concuerror_log:event(), state()) -> {'ok', state()}.
handle_event({msg, String, MsgVerb}, {Verb, _Progress}=State) ->
if
Verb >= MsgVerb ->
io:format("~s", [String]);
true ->
ok
end,
{ok, State};
handle_event({progress, _Type}, {_Verb, 'noprogress'}=State) ->
{ok, State};
handle_event({progress, Type}, {Verb, Progress}) ->
case concuerror_util:progress_bar(Type, Progress) of
{NewProgress, ""} ->
{ok, {Verb, NewProgress}};
{NewProgress, Msg} ->
io:fwrite("\r\033[K" ++ Msg),
{ok, {Verb, NewProgress}}
end;
handle_event('reset', {_Verb, 'noprogress'}=State) ->
{ok, State};
handle_event('reset', {Verb, _Progress}) ->
{ok, {Verb, concuerror_util:init_state()}}.
================================================
FILE: resources/old_source/concuerror_deps.erl
================================================
%%%----------------------------------------------------------------------
%%% Copyright (c) 2013, Alkis Gotovos <el3ctrologos@hotmail.com>,
%%% Maria Christakis <mchrista@softlab.ntua.gr>
%%% and Kostis Sagonas <kostis@cs.ntua.gr>.
%%% All rights reserved.
%%%
%%% This file is distributed under the Simplified BSD License.
%%% Details can be found in the LICENSE file.
%%%----------------------------------------------------------------------
%%% Authors : Stavros Aronis <aronisstav@gmail.com>
%%% Description : Dependency relation for Erlang
%%%----------------------------------------------------------------------
-module(concuerror_deps).
-export([may_have_dependencies/1,
gitextract_f2h5wf0f/
├── .editorconfig
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── feature_request.md
│ │ └── other-issue.md
│ ├── codecov.yml
│ ├── pull_request_template.md
│ ├── scripts/
│ │ ├── covertool_combine
│ │ └── covertool_setup
│ └── workflows/
│ ├── tests.yml
│ └── website.yml
├── .gitignore
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── bin/
│ └── .gitignore
├── cover/
│ ├── .gitignore
│ └── cover-report
├── doc/
│ ├── .gitignore
│ ├── Gemfile
│ ├── Makefile
│ └── overview.edoc
├── docs/
│ ├── .bundle/
│ │ └── config
│ ├── .gitignore
│ ├── 404.md
│ ├── CNAME
│ ├── Gemfile
│ ├── Makefile
│ ├── README.md
│ ├── _config.yml
│ ├── _config_local.yml
│ ├── _data/
│ │ ├── authors.yml
│ │ ├── navigation.yml
│ │ └── text.yml
│ ├── _includes/
│ │ ├── footer-custom.html
│ │ ├── head-custom.html
│ │ ├── masthead.html
│ │ └── yt.html
│ ├── _posts/
│ │ ├── 2013-09-03-site.md
│ │ ├── 2013-09-23-euc-2013.md
│ │ ├── 2014-06-02-poolboy-example.md
│ │ ├── 2014-06-03-poolboy-example-errors.md
│ │ ├── 2014-08-11-euc-2014.md
│ │ ├── 2015-06-10-euc-2015.md
│ │ ├── 2017-08-14-euc-2017-talk.md
│ │ ├── 2017-08-14-euc-2017-tutorial.md
│ │ ├── 2017-10-03-publications-update.md
│ │ ├── 2017-10-08-concuerror-eunit.md
│ │ ├── 2017-10-14-concuerring-concuerror-ep-1.md
│ │ ├── 2017-11-06-Announcing-Mailing-List.md
│ │ ├── 2018-07-15-hex.md
│ │ ├── 2020-10-10-tips.md
│ │ ├── 2020-10-17-code-beam-sf-2019.md
│ │ ├── 2020-10-17-functional-conf-2018.md
│ │ └── 2020-10-24-basic-tutorial.md
│ ├── contact.md
│ ├── download.md
│ ├── faq.md
│ ├── feed.xml
│ ├── index.md
│ ├── news.md
│ ├── publications.md
│ ├── search.md
│ ├── sitemap.xml
│ └── tutorials.md
├── elvis.config
├── priv/
│ ├── concuerror
│ ├── generate_option_docfiles
│ └── generate_version_hrl
├── rebar.config
├── resources/
│ ├── DPOR_paper_material/
│ │ ├── DPOR_README
│ │ ├── foo.erl
│ │ ├── foobar.erl
│ │ ├── my_test.erl
│ │ ├── run_dialyzer.sh
│ │ ├── run_filesystem.sh
│ │ ├── run_indexer.sh
│ │ ├── run_last_zero.sh
│ │ ├── run_readers.sh
│ │ └── run_rush_hour.sh
│ ├── bash_completion/
│ │ └── concuerror
│ ├── erlang_questions/
│ │ └── dets_bugs/
│ │ ├── alt_dets_bugs.erl
│ │ └── dets_bugs.erl
│ ├── flanagan.erl
│ ├── how-to-release.md
│ ├── old_include/
│ │ ├── gen.hrl
│ │ ├── gui.hrl
│ │ └── instr.hrl
│ ├── old_source/
│ │ ├── LICENSE
│ │ ├── concuerror.erl
│ │ ├── concuerror_deps.erl
│ │ ├── concuerror_error.erl
│ │ ├── concuerror_gui.erl
│ │ ├── concuerror_instr.erl
│ │ ├── concuerror_io_server.erl
│ │ ├── concuerror_lid.erl
│ │ ├── concuerror_log.erl
│ │ ├── concuerror_proc_action.erl
│ │ ├── concuerror_rep.erl
│ │ ├── concuerror_sched.erl
│ │ ├── concuerror_state.erl
│ │ ├── concuerror_ticket.erl
│ │ └── concuerror_util.erl
│ ├── perm_tests/
│ │ ├── run_perm_tests
│ │ └── src/
│ │ ├── complete_test_3.erl
│ │ ├── conditional_readers_3.erl
│ │ ├── depend_4_1.erl
│ │ ├── depend_4_2.erl
│ │ ├── depend_4_3.erl
│ │ ├── depend_6_1.erl
│ │ ├── depend_6_2.erl
│ │ ├── depend_6_3.erl
│ │ ├── depend_6_4.erl
│ │ ├── depend_6_5.erl
│ │ ├── etsi.erl
│ │ ├── readers_2.erl
│ │ └── readers_3.erl
│ ├── syntax/
│ │ ├── block_after.erl
│ │ ├── non_local_pat.erl
│ │ ├── rec_uscore.erl
│ │ └── strip_attr.erl
│ ├── tdd/
│ │ ├── reg_server.erl
│ │ ├── reg_server.hrl
│ │ └── reg_server_tests.erl
│ └── utest/
│ ├── concuerror_error_tests.erl
│ ├── concuerror_instr_tests.erl
│ ├── concuerror_lid_tests.erl
│ ├── concuerror_state_tests.erl
│ └── concuerror_ticket_tests.erl
├── src/
│ ├── .gitignore
│ ├── concuerror.app.src
│ ├── concuerror.erl
│ ├── concuerror.hrl
│ ├── concuerror_callback.erl
│ ├── concuerror_dependencies.erl
│ ├── concuerror_estimator.erl
│ ├── concuerror_inspect.erl
│ ├── concuerror_instrumenter.erl
│ ├── concuerror_io_lib.erl
│ ├── concuerror_loader.erl
│ ├── concuerror_logger.erl
│ ├── concuerror_options.erl
│ ├── concuerror_scheduler.erl
│ └── concuerror_window_average.erl
├── test/
│ ├── README.md
│ ├── concuerror_logger_tests.erl
│ └── concuerror_options_tests.erl
├── tests/
│ ├── README.md
│ ├── differ
│ ├── results/
│ │ └── .gitignore
│ ├── runtests.py
│ ├── scenarios.erl
│ ├── suites/
│ │ ├── advanced_tests/
│ │ │ ├── results/
│ │ │ │ ├── gen_server_bug-test_register-inf-dpor.txt
│ │ │ │ ├── gen_server_bug-test_without_register-inf-dpor.txt
│ │ │ │ ├── manolis-test_2workers_small-inf-dpor.txt
│ │ │ │ ├── percept-test-inf-dpor.txt
│ │ │ │ ├── preemption-preemption-inf-dpor.txt
│ │ │ │ ├── receive_deps-test-inf-dpor.txt
│ │ │ │ ├── receive_deps_kill-test-inf-dpor.txt
│ │ │ │ ├── receive_pats-test1-inf-dpor.txt
│ │ │ │ ├── receive_pats-test2-inf-dpor.txt
│ │ │ │ ├── receive_pats-test3-inf-dpor.txt
│ │ │ │ ├── receive_pats-test4-inf-dpor.txt
│ │ │ │ ├── receive_patterns-test1-inf-optimal.txt
│ │ │ │ ├── receive_patterns-test2-inf-optimal.txt
│ │ │ │ ├── ring_leader_election-ring_leader_election-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_barrier-ring_leader_election_barrier-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric-ring_leader_election_symmetric-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric_buffer-ring_leader_election_symmetric_buffer-inf-dpor.txt
│ │ │ │ ├── ring_leader_election_symmetric_buffer_2-ring_leader_election_symmetric_buffer_2-inf-dpor.txt
│ │ │ │ ├── shared_ptr-shared_ptr-inf-dpor.txt
│ │ │ │ ├── shootout-test1-inf-dpor.txt
│ │ │ │ ├── simple_registry-simple_registry-inf-dpor.txt
│ │ │ │ ├── source_killer-test-inf-dpor.txt
│ │ │ │ ├── source_killer-test-inf-source.txt
│ │ │ │ └── vjeko_peer-concuerror_test-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── gen_server_bug.erl
│ │ │ ├── indexer_example.erl
│ │ │ ├── manolis/
│ │ │ │ ├── good_testcase.txt
│ │ │ │ ├── readme.txt
│ │ │ │ ├── rush_hour.erl
│ │ │ │ ├── search.erl
│ │ │ │ └── test.erl
│ │ │ ├── percept.erl
│ │ │ ├── preemption.erl
│ │ │ ├── receive_deps.erl
│ │ │ ├── receive_deps_kill.erl
│ │ │ ├── receive_pats.erl
│ │ │ ├── receive_patterns.erl
│ │ │ ├── ring_leader_election.erl
│ │ │ ├── ring_leader_election_barrier.erl
│ │ │ ├── ring_leader_election_symmetric.erl
│ │ │ ├── ring_leader_election_symmetric_buffer.erl
│ │ │ ├── ring_leader_election_symmetric_buffer_2.erl
│ │ │ ├── send_order.erl
│ │ │ ├── shared_ptr.erl
│ │ │ ├── shootout/
│ │ │ │ ├── pidigits.erl
│ │ │ │ ├── test.erl
│ │ │ │ └── thread_ring.erl
│ │ │ ├── simple_registry.erl
│ │ │ ├── source_killer.erl
│ │ │ └── vjeko_peer.erl
│ │ ├── basic_tests/
│ │ │ ├── results/
│ │ │ │ ├── ac_tab_insert-test-inf-optimal.txt
│ │ │ │ ├── after_test_2-after_test_2-inf-dpor.txt
│ │ │ │ ├── after_test_3-after_test_3-inf-dpor.txt
│ │ │ │ ├── after_vs_trap_exit-after_vs_trap_exit-inf-dpor.txt
│ │ │ │ ├── allow_first_crash-test-inf-dpor.txt
│ │ │ │ ├── assert_filter-test-inf-dpor.txt
│ │ │ │ ├── bad_dictionary-bad_erase-inf-optimal.txt
│ │ │ │ ├── bad_dictionary-bad_get-inf-optimal.txt
│ │ │ │ ├── bad_dictionary-bad_put-inf-optimal.txt
│ │ │ │ ├── bad_whereis-test-inf-dpor.txt
│ │ │ │ ├── code_when_undef-test-inf-optimal.txt
│ │ │ │ ├── concuerror_crash-test-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test1-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test2-inf-dpor.txt
│ │ │ │ ├── curious_builtins-test3-inf-dpor.txt
│ │ │ │ ├── dead_receive-dead_receive-inf-dpor.txt
│ │ │ │ ├── deeper_exit-test-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_both-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_flush-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_info-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-child_none-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_both-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_flush-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_info-inf-dpor.txt
│ │ │ │ ├── demonitor_exhaustive-parent_none-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test1-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test2-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test3-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test4-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test5-inf-dpor.txt
│ │ │ │ ├── demonitor_flush-test6-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test1-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test2-inf-dpor.txt
│ │ │ │ ├── demonitor_sane_opts-test3-inf-dpor.txt
│ │ │ │ ├── depth_bound-test-inf-dpor.txt
│ │ │ │ ├── erlang_display-test-inf-dpor.txt
│ │ │ │ ├── erlang_display_string-test-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete_bad-inf-dpor.txt
│ │ │ │ ├── ets_delete-ets_delete_plain-inf-dpor.txt
│ │ │ │ ├── ets_delete_2-ets_delete_2-inf-dpor.txt
│ │ │ │ ├── ets_delete_2-ets_delete_2_twice-inf-dpor.txt
│ │ │ │ ├── ets_delete_all-delete_all_bad-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-delete_all_good-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-race_delete_all_read-inf-optimal.txt
│ │ │ │ ├── ets_delete_all-race_delete_all_write-inf-optimal.txt
│ │ │ │ ├── ets_delete_object-test1-inf-dpor.txt
│ │ │ │ ├── ets_delete_object-test2-inf-dpor.txt
│ │ │ │ ├── ets_delete_object-test3-inf-dpor.txt
│ │ │ │ ├── ets_exceptions-test-inf-dpor.txt
│ │ │ │ ├── ets_give_away-give_away_bad-inf-optimal.txt
│ │ │ │ ├── ets_give_away-give_away_good-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_delete-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_exit-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_new-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_rename_free-inf-optimal.txt
│ │ │ │ ├── ets_global_global-new_rename_taken-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_delete-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_exit-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_rename_free-inf-optimal.txt
│ │ │ │ ├── ets_global_global-rename_rename_taken-inf-optimal.txt
│ │ │ │ ├── ets_heir-ets_heir-inf-dpor.txt
│ │ │ │ ├── ets_heir-test-inf-dpor.txt
│ │ │ │ ├── ets_heir-test1-inf-dpor.txt
│ │ │ │ ├── ets_heir-test2-inf-dpor.txt
│ │ │ │ ├── ets_heir_2-ets_heir_2-inf-dpor.txt
│ │ │ │ ├── ets_info-info_2_badarg-inf-optimal.txt
│ │ │ │ ├── ets_info-info_bad-inf-optimal.txt
│ │ │ │ ├── ets_info-info_badarg-inf-optimal.txt
│ │ │ │ ├── ets_info-info_good-inf-optimal.txt
│ │ │ │ ├── ets_info-info_system-inf-optimal.txt
│ │ │ │ ├── ets_info_details-test-inf-optimal.txt
│ │ │ │ ├── ets_insert_new-test-inf-dpor.txt
│ │ │ │ ├── ets_insert_objects-ets_insert_objects-inf-dpor.txt
│ │ │ │ ├── ets_many_insert_new-ets_many_insert_new-inf-dpor.txt
│ │ │ │ ├── ets_new-test-inf-dpor.txt
│ │ │ │ ├── ets_new-test-inf.txt
│ │ │ │ ├── ets_new_failure-ets_new_failure-inf-dpor.txt
│ │ │ │ ├── ets_new_failure_2-ets_new_failure_2-inf-dpor.txt
│ │ │ │ ├── ets_new_failure_3-ets_new_failure_3-inf-dpor.txt
│ │ │ │ ├── ets_ref_keys-ets_ref_keys-0.txt
│ │ │ │ ├── ets_ref_keys-ets_ref_keys-inf-dpor.txt
│ │ │ │ ├── ets_rename-rename_bad-inf-optimal.txt
│ │ │ │ ├── ets_rename-rename_good-inf-optimal.txt
│ │ │ │ ├── ets_rename-rename_public-inf-optimal.txt
│ │ │ │ ├── ets_select-match_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-match_object_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_any-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_different_tuples-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_any-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_keys-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_matchspec-inf-dpor.txt
│ │ │ │ ├── ets_select-select_delete_against_matching_tuples-inf-dpor.txt
│ │ │ │ ├── ets_unguarded-test-inf-optimal.txt
│ │ │ │ ├── ets_unnamed-test1-inf-dpor.txt
│ │ │ │ ├── ets_unnamed-test2-inf-dpor.txt
│ │ │ │ ├── ets_unnamed-test3-inf-dpor.txt
│ │ │ │ ├── ets_update_counter-test-inf-dpor.txt
│ │ │ │ ├── ets_update_counter-test1-inf-dpor.txt
│ │ │ │ ├── ets_update_element-race_update_element_r-inf-optimal.txt
│ │ │ │ ├── ets_update_element-race_update_element_w-inf-optimal.txt
│ │ │ │ ├── ets_update_element-update_element_bad-inf-optimal.txt
│ │ │ │ ├── ets_update_element-update_element_good-inf-optimal.txt
│ │ │ │ ├── ets_whereis-race_whereis_r-inf-optimal.txt
│ │ │ │ ├── ets_whereis-race_whereis_w-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_bad-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_badarg-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_good-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_del-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_exit-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_wr-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_race_ww-inf-optimal.txt
│ │ │ │ ├── ets_whereis-whereis_system-inf-optimal.txt
│ │ │ │ ├── exit-test1-inf-dpor.txt
│ │ │ │ ├── exit-test1-inf.txt
│ │ │ │ ├── exit-test2-inf-dpor.txt
│ │ │ │ ├── exit-test2-inf.txt
│ │ │ │ ├── exit-test3-inf-dpor.txt
│ │ │ │ ├── exit-test3-inf.txt
│ │ │ │ ├── exit-test4-inf-dpor.txt
│ │ │ │ ├── exit-test5-inf-dpor.txt
│ │ │ │ ├── exit-test6-inf-dpor.txt
│ │ │ │ ├── exit_kill-test-inf-dpor.txt
│ │ │ │ ├── exit_message_unpredicted-exit_message_unpredicted-inf-dpor.txt
│ │ │ │ ├── file_read_file-test-inf-dpor.txt
│ │ │ │ ├── fun_fail-test1-inf-dpor.txt
│ │ │ │ ├── fun_fail-test2-inf-dpor.txt
│ │ │ │ ├── fun_fail-test3-inf-dpor.txt
│ │ │ │ ├── group_leader-test-inf-dpor.txt
│ │ │ │ ├── group_leader-test1-inf-dpor.txt
│ │ │ │ ├── group_leader2-test-inf-dpor.txt
│ │ │ │ ├── group_leader3-test-inf-dpor.txt
│ │ │ │ ├── halt_error-test1-inf-optimal.txt
│ │ │ │ ├── halt_error-test2-inf-optimal.txt
│ │ │ │ ├── hibernate-test-inf-optimal.txt
│ │ │ │ ├── hopeless_after-hopeless_after-inf-dpor.txt
│ │ │ │ ├── i_hate_myself-i_hate_myself-inf-dpor.txt
│ │ │ │ ├── ignore_error_1-test-inf-dpor.txt
│ │ │ │ ├── ignore_error_2-test-inf-dpor.txt
│ │ │ │ ├── ignore_error_3-test-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test1-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test2-inf-dpor.txt
│ │ │ │ ├── immediate_delivery-test3-inf-dpor.txt
│ │ │ │ ├── init_race_condition-test-inf-dpor.txt
│ │ │ │ ├── init_race_condition-test-inf.txt
│ │ │ │ ├── inspect_system-test-inf-dpor.txt
│ │ │ │ ├── instr_apply-test-inf-dpor.txt
│ │ │ │ ├── instr_apply-test-inf.txt
│ │ │ │ ├── io_error-test-inf-dpor.txt
│ │ │ │ ├── io_format-test-inf-dpor.txt
│ │ │ │ ├── io_format_2-test-inf-dpor.txt
│ │ │ │ ├── io_format_3-test-inf-dpor.txt
│ │ │ │ ├── irrelevant_send-irrelevant_send-inf-dpor.txt
│ │ │ │ ├── is_process_alive_1-is_process_alive_1-inf-dpor.txt
│ │ │ │ ├── keep_going-test-inf-dpor.txt
│ │ │ │ ├── kill_running_waiting-test-inf-dpor.txt
│ │ │ │ ├── late_hope-late_hope-inf-dpor.txt
│ │ │ │ ├── lid_test-test-inf-dpor.txt
│ │ │ │ ├── link_after-link_after-inf-dpor.txt
│ │ │ │ ├── load_before_start-test-inf-dpor.txt
│ │ │ │ ├── main_and_backup-main_and_backup-inf-dpor.txt
│ │ │ │ ├── many_kill-test-inf-dpor.txt
│ │ │ │ ├── many_links-many_links-inf-dpor.txt
│ │ │ │ ├── many_monitors-many_monitors-inf-dpor.txt
│ │ │ │ ├── many_send_to_dead-many_send_to_dead-inf-dpor.txt
│ │ │ │ ├── many_send_to_dead_2-many_send_to_dead_2-inf-dpor.txt
│ │ │ │ ├── message_queue_length-test-inf-optimal.txt
│ │ │ │ ├── messed_deliveries-test-inf-dpor.txt
│ │ │ │ ├── module_loaded_dep-test-inf-optimal.txt
│ │ │ │ ├── monitor_demonitor-monitor_demonitor-inf-dpor.txt
│ │ │ │ ├── monitor_failure-monitor_failure-inf-dpor.txt
│ │ │ │ ├── monitor_info-test1-inf-dpor.txt
│ │ │ │ ├── monitor_info-test2-inf-dpor.txt
│ │ │ │ ├── monitor_missing_messages-monitor_missing_messages-inf-dpor.txt
│ │ │ │ ├── monitor_named-test-inf-dpor.txt
│ │ │ │ ├── monitor_order-test-inf-optimal.txt
│ │ │ │ ├── monotonic_time-test-inf-optimal.txt
│ │ │ │ ├── node_names-test1-inf-dpor.txt
│ │ │ │ ├── node_names-test2-inf-dpor.txt
│ │ │ │ ├── normal_exit-normal_exit-inf-dpor.txt
│ │ │ │ ├── normal_shutdown-test-inf-dpor.txt
│ │ │ │ ├── normal_tuple_exit-test-inf-dpor.txt
│ │ │ │ ├── os_timestamp-test-inf-dpor.txt
│ │ │ │ ├── pids_are_unsafe-test-inf-dpor.txt
│ │ │ │ ├── process_flag_link-process_flag_link-inf-dpor.txt
│ │ │ │ ├── process_info-test1-inf-dpor.txt
│ │ │ │ ├── process_info-test2-inf-dpor.txt
│ │ │ │ ├── process_info-test3-inf-dpor.txt
│ │ │ │ ├── process_info-test_current_function-inf-dpor.txt
│ │ │ │ ├── process_info-test_current_function_top-inf-dpor.txt
│ │ │ │ ├── process_info-test_message_queue_len-inf-dpor.txt
│ │ │ │ ├── process_info-test_messages-inf-dpor.txt
│ │ │ │ ├── process_info-test_mql_flush-inf-dpor.txt
│ │ │ │ ├── processes-test1-inf-dpor.txt
│ │ │ │ ├── processes-test2-inf-dpor.txt
│ │ │ │ ├── processes_leader-test-inf-optimal.txt
│ │ │ │ ├── racing_after-test-inf-dpor.txt
│ │ │ │ ├── receive_after-receive_after-inf-dpor.txt
│ │ │ │ ├── receive_and_after-receive_and_after-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test1-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test2-inf-dpor.txt
│ │ │ │ ├── receive_catchall-test3-inf-dpor.txt
│ │ │ │ ├── receive_exit-test-inf-dpor.txt
│ │ │ │ ├── receive_exit-test1-inf-dpor.txt
│ │ │ │ ├── receive_exit-test2-inf-dpor.txt
│ │ │ │ ├── receive_exit-test3-inf-dpor.txt
│ │ │ │ ├── receive_with_guard-receive_with_guard-inf-dpor.txt
│ │ │ │ ├── receive_without_trapping-receive_without_trapping-inf-dpor.txt
│ │ │ │ ├── register_link-test-inf-optimal.txt
│ │ │ │ ├── registered_1-registered_1-inf-dpor.txt
│ │ │ │ ├── registered_2-registered_2-inf-dpor.txt
│ │ │ │ ├── registered_send_1-registered_send_1-inf-dpor.txt
│ │ │ │ ├── registered_send_2-registered_send_2-inf-dpor.txt
│ │ │ │ ├── registered_send_3-registered_send_3-inf-dpor.txt
│ │ │ │ ├── replay_sanity-replay_sanity-inf-dpor.txt
│ │ │ │ ├── report_blocks-test-inf-dpor.txt
│ │ │ │ ├── reuse_raw_pid-test-inf-dpor.txt
│ │ │ │ ├── safeops_coverage-test-inf-optimal.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-2-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-2.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-0.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-1-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-1.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-2-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-2.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-3-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-3.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-4-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-4.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-5-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-5.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-6-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-6.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-7-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-7.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_3_proc_send_receive-inf.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-0-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-0.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-1-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-1.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-2-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-2.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-3-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-3.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_after_clause_preemption-inf.txt
│ │ │ │ ├── sched_tests-test_halt_0-0-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_0-0.txt
│ │ │ │ ├── sched_tests-test_halt_0-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_0-inf.txt
│ │ │ │ ├── sched_tests-test_halt_1-0-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_1-0.txt
│ │ │ │ ├── sched_tests-test_halt_1-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_halt_1-inf.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_link_unlink-0-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-0.txt
│ │ │ │ ├── sched_tests-test_link_unlink-1-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-1.txt
│ │ │ │ ├── sched_tests-test_link_unlink-2-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-2.txt
│ │ │ │ ├── sched_tests-test_link_unlink-3-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-3.txt
│ │ │ │ ├── sched_tests-test_link_unlink-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_link_unlink-inf.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-0-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-0.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-1-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-1.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_monitor_unexisting-inf.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-0-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-0.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-1-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-1.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-2-dpor.txt
│ │ │ │ ├── sched_tests-test_nested_send_receive_block_twice-2.txt
│ │ │ │ ├── sched_tests-test_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive-0.txt
│ │ │ │ ├── sched_tests-test_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive-inf.txt
│ │ │ │ ├── sched_tests-test_receive_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_2-0.txt
│ │ │ │ ├── sched_tests-test_receive_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_2-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_block_expr_action-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_no_patterns-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_infinity_with_pattern-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-1-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-1.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-2-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-2.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_no_patterns-inf.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-0-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-0.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-1-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-1.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-2-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-2.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-3-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-3.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_receive_after_with_pattern-inf.txt
│ │ │ │ ├── sched_tests-test_register_unregister-0-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-0.txt
│ │ │ │ ├── sched_tests-test_register_unregister-1-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-1.txt
│ │ │ │ ├── sched_tests-test_register_unregister-2-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-2.txt
│ │ │ │ ├── sched_tests-test_register_unregister-3-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-3.txt
│ │ │ │ ├── sched_tests-test_register_unregister-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_register_unregister-inf.txt
│ │ │ │ ├── sched_tests-test_send-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send-0.txt
│ │ │ │ ├── sched_tests-test_send-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send-1.txt
│ │ │ │ ├── sched_tests-test_send-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send-inf.txt
│ │ │ │ ├── sched_tests-test_send_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-0.txt
│ │ │ │ ├── sched_tests-test_send_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-1.txt
│ │ │ │ ├── sched_tests-test_send_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_2-inf.txt
│ │ │ │ ├── sched_tests-test_send_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-0.txt
│ │ │ │ ├── sched_tests-test_send_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-1.txt
│ │ │ │ ├── sched_tests-test_send_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_3-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-0.txt
│ │ │ │ ├── sched_tests-test_send_receive-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-1.txt
│ │ │ │ ├── sched_tests-test_send_receive-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-2.txt
│ │ │ │ ├── sched_tests-test_send_receive-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-0.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-1.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-2.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_2-inf.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-0.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-1.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-2-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-2.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_send_receive_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-0.txt
│ │ │ │ ├── sched_tests-test_spawn-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-1.txt
│ │ │ │ ├── sched_tests-test_spawn-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_race-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-2-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-2.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_2-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-0.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-1.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_link_unlink_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_2-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_3-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-0.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-1.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_monitor_demonitor_4-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-0.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-1.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_link_receive_exit-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-0.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_opt_monitor-inf.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-0-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-0.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-1-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-1.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-2-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-2.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_spawn_register_race-inf.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-0-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-0.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-1-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-1.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_trap_exit_timing-inf.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-0-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-0.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-1-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-1.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_var_mod_fun-inf.txt
│ │ │ │ ├── sched_tests-test_whereis-0-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-0.txt
│ │ │ │ ├── sched_tests-test_whereis-1-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-1.txt
│ │ │ │ ├── sched_tests-test_whereis-2-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-2.txt
│ │ │ │ ├── sched_tests-test_whereis-inf-dpor.txt
│ │ │ │ ├── sched_tests-test_whereis-inf.txt
│ │ │ │ ├── self_exits-test1-inf-dpor.txt
│ │ │ │ ├── self_exits-test2-inf-dpor.txt
│ │ │ │ ├── self_exits-test3-inf-dpor.txt
│ │ │ │ ├── self_exits-test4-inf-dpor.txt
│ │ │ │ ├── send_after-test1-inf-dpor.txt
│ │ │ │ ├── send_after-test11-inf-dpor.txt
│ │ │ │ ├── send_after-test12-inf-dpor.txt
│ │ │ │ ├── send_after-test13-inf-dpor.txt
│ │ │ │ ├── send_after-test14-inf-dpor.txt
│ │ │ │ ├── send_after-test15-inf-dpor.txt
│ │ │ │ ├── send_after-test16-inf-dpor.txt
│ │ │ │ ├── send_after-test17-inf-dpor.txt
│ │ │ │ ├── send_after-test18-inf-dpor.txt
│ │ │ │ ├── send_after-test19-inf-dpor.txt
│ │ │ │ ├── send_after-test1A-inf-dpor.txt
│ │ │ │ ├── send_after-test1B-inf-dpor.txt
│ │ │ │ ├── send_after-test1C-inf-dpor.txt
│ │ │ │ ├── send_after-test1D-inf-dpor.txt
│ │ │ │ ├── send_after-test2-inf-dpor.txt
│ │ │ │ ├── send_after-test3-inf-dpor.txt
│ │ │ │ ├── send_after-test4-inf-dpor.txt
│ │ │ │ ├── send_after-test5-inf-dpor.txt
│ │ │ │ ├── send_after-test6-inf-dpor.txt
│ │ │ │ ├── send_after-test7-inf-dpor.txt
│ │ │ │ ├── send_after-test8-inf-dpor.txt
│ │ │ │ ├── send_after-test9-inf-dpor.txt
│ │ │ │ ├── send_after-testA-inf-dpor.txt
│ │ │ │ ├── send_after-testB-inf-dpor.txt
│ │ │ │ ├── send_after-testC-inf-dpor.txt
│ │ │ │ ├── send_after_trouble-test-inf-dpor.txt
│ │ │ │ ├── send_named_vs_send-send_named_vs_send-inf-dpor.txt
│ │ │ │ ├── send_receive_dependencies-send_receive_dependencies-inf-dpor.txt
│ │ │ │ ├── send_self-test-inf-dpor.txt
│ │ │ │ ├── send_self-test1-inf-dpor.txt
│ │ │ │ ├── send_self-test2-inf-dpor.txt
│ │ │ │ ├── send_self-test3-inf-dpor.txt
│ │ │ │ ├── send_using_names-send_using_names-inf-dpor.txt
│ │ │ │ ├── send_vs_trap_exit-send_vs_trap_exit-inf-dpor.txt
│ │ │ │ ├── signals_vs_messages-test-inf-dpor.txt
│ │ │ │ ├── signals_vs_messages-test1-inf-dpor.txt
│ │ │ │ ├── simple_ets-simple_ets-inf-dpor.txt
│ │ │ │ ├── simple_spawn-simple_spawn-inf-dpor.txt
│ │ │ │ ├── sleep_set_block_not_bad-test-inf-persistent.txt
│ │ │ │ ├── spawn_and_send-spawn_and_send-inf-dpor.txt
│ │ │ │ ├── spawn_bad-test-inf-dpor.txt
│ │ │ │ ├── spawn_failure-spawn_failure-inf-dpor.txt
│ │ │ │ ├── spawn_monitor_test-spawn_monitor_test-inf-dpor.txt
│ │ │ │ ├── spawned_sender_crasher-spawned_sender_crasher-inf-dpor.txt
│ │ │ │ ├── spawned_senders-spawned_senders-inf-dpor.txt
│ │ │ │ ├── stacktrace_vs_exit-test-inf-optimal.txt
│ │ │ │ ├── system_info-test-inf-optimal.txt
│ │ │ │ ├── system_instant_delivery-test-inf-optimal.txt
│ │ │ │ ├── system_non_instant_delivery-test-inf-optimal.txt
│ │ │ │ ├── timers_afters_exits_crashes-both_crash-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-child_crashes-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_exit_bad-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_exit_ok-inf-dpor.txt
│ │ │ │ ├── timers_afters_exits_crashes-my_start_timer-inf-dpor.txt
│ │ │ │ ├── timestamps-exit_system_time0-inf-optimal.txt
│ │ │ │ ├── timestamps-exit_system_time1-inf-optimal.txt
│ │ │ │ ├── timestamps-exit_timestamp-inf-optimal.txt
│ │ │ │ ├── timestamps-other_system_time0-inf-optimal.txt
│ │ │ │ ├── timestamps-other_system_time1-inf-optimal.txt
│ │ │ │ ├── timestamps-other_timestamp-inf-optimal.txt
│ │ │ │ ├── trace_the_sender-trace_the_sender-inf-dpor.txt
│ │ │ │ ├── transparent_instrumentation-test-inf-dpor.txt
│ │ │ │ ├── trigger_the_after-trigger_the_after-inf-dpor.txt
│ │ │ │ ├── unregister_deadlocked-test1-inf-dpor.txt
│ │ │ │ └── waiting-waiting-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── ac_tab_delete_crash.erl
│ │ │ ├── ac_tab_insert.erl
│ │ │ ├── after_test_2.erl
│ │ │ ├── after_test_3.erl
│ │ │ ├── after_vs_trap_exit.erl
│ │ │ ├── allow_first_crash.erl
│ │ │ ├── application_check.erl
│ │ │ ├── assert_filter.erl
│ │ │ ├── assert_tip.erl
│ │ │ ├── bad_dictionary.erl
│ │ │ ├── bad_whereis.erl
│ │ │ ├── code_when_undef.erl
│ │ │ ├── concuerror_crash.erl
│ │ │ ├── curious_builtins.erl
│ │ │ ├── dead_receive.erl
│ │ │ ├── deeper_exit.erl
│ │ │ ├── demonitor_exhaustive.erl
│ │ │ ├── demonitor_flush.erl
│ │ │ ├── demonitor_sane_opts.erl
│ │ │ ├── depth_bound.erl
│ │ │ ├── erlang_display.erl
│ │ │ ├── erlang_display_string.erl
│ │ │ ├── ets_delete.erl
│ │ │ ├── ets_delete_2.erl
│ │ │ ├── ets_delete_all.erl
│ │ │ ├── ets_delete_object.erl
│ │ │ ├── ets_exceptions.erl
│ │ │ ├── ets_give_away.erl
│ │ │ ├── ets_global_global.erl
│ │ │ ├── ets_heir.erl
│ │ │ ├── ets_heir_2.erl
│ │ │ ├── ets_info.erl
│ │ │ ├── ets_info_details.erl
│ │ │ ├── ets_insert_new.erl
│ │ │ ├── ets_insert_objects.erl
│ │ │ ├── ets_many_insert_new.erl
│ │ │ ├── ets_new.erl
│ │ │ ├── ets_new_failure.erl
│ │ │ ├── ets_new_failure_2.erl
│ │ │ ├── ets_new_failure_3.erl
│ │ │ ├── ets_ref_keys.erl
│ │ │ ├── ets_rename.erl
│ │ │ ├── ets_select.erl
│ │ │ ├── ets_unguarded.erl
│ │ │ ├── ets_unnamed.erl
│ │ │ ├── ets_update_counter.erl
│ │ │ ├── ets_update_element.erl
│ │ │ ├── ets_whereis.erl
│ │ │ ├── exit.erl
│ │ │ ├── exit_kill.erl
│ │ │ ├── exit_message_unpredicted.erl
│ │ │ ├── file_read_file.erl
│ │ │ ├── fun_fail.erl
│ │ │ ├── group_leader.erl
│ │ │ ├── group_leader2.erl
│ │ │ ├── group_leader3.erl
│ │ │ ├── halt_error.erl
│ │ │ ├── halt_support.erl
│ │ │ ├── hibernate.erl
│ │ │ ├── hopeless_after.erl
│ │ │ ├── i_hate_myself.erl
│ │ │ ├── ignore_error_1.erl
│ │ │ ├── ignore_error_2.erl
│ │ │ ├── ignore_error_3.erl
│ │ │ ├── immediate_delivery.erl
│ │ │ ├── infinite_loop.erl
│ │ │ ├── init_race_condition.erl
│ │ │ ├── inspect_system.erl
│ │ │ ├── instr_apply.erl
│ │ │ ├── io_error.erl
│ │ │ ├── io_format.erl
│ │ │ ├── io_format_2.erl
│ │ │ ├── io_format_3.erl
│ │ │ ├── irrelevant_send.erl
│ │ │ ├── is_process_alive_1.erl
│ │ │ ├── keep_going.erl
│ │ │ ├── kill_running_waiting.erl
│ │ │ ├── late_hope.erl
│ │ │ ├── lid_test.erl
│ │ │ ├── link_after.erl
│ │ │ ├── load_before_start.erl
│ │ │ ├── log_all.erl
│ │ │ ├── main_and_backup.erl
│ │ │ ├── many_kill.erl
│ │ │ ├── many_links.erl
│ │ │ ├── many_monitors.erl
│ │ │ ├── many_send_to_dead.erl
│ │ │ ├── many_send_to_dead_2.erl
│ │ │ ├── message_queue_length.erl
│ │ │ ├── messed_deliveries.erl
│ │ │ ├── module_loaded_dep.erl
│ │ │ ├── monitor_demonitor.erl
│ │ │ ├── monitor_failure.erl
│ │ │ ├── monitor_info.erl
│ │ │ ├── monitor_missing_messages.erl
│ │ │ ├── monitor_named.erl
│ │ │ ├── monitor_order.erl
│ │ │ ├── monotonic_time.erl
│ │ │ ├── node_names.erl
│ │ │ ├── nonexistent_module.erl
│ │ │ ├── normal_exit.erl
│ │ │ ├── normal_shutdown.erl
│ │ │ ├── normal_tuple_exit.erl
│ │ │ ├── os_timestamp.erl
│ │ │ ├── pids_are_unsafe.erl
│ │ │ ├── process_flag_link.erl
│ │ │ ├── process_info.erl
│ │ │ ├── processes.erl
│ │ │ ├── processes_leader.erl
│ │ │ ├── racing_after.erl
│ │ │ ├── receive_after.erl
│ │ │ ├── receive_and_after.erl
│ │ │ ├── receive_catchall.erl
│ │ │ ├── receive_exit.erl
│ │ │ ├── receive_loop.erl
│ │ │ ├── receive_with_guard.erl
│ │ │ ├── receive_without_trapping.erl
│ │ │ ├── register_link.erl
│ │ │ ├── registered_1.erl
│ │ │ ├── registered_2.erl
│ │ │ ├── registered_send_1.erl
│ │ │ ├── registered_send_2.erl
│ │ │ ├── registered_send_3.erl
│ │ │ ├── replay_sanity.erl
│ │ │ ├── report_blocks.erl
│ │ │ ├── reuse_raw_pid.erl
│ │ │ ├── safeops_coverage.erl
│ │ │ ├── sched_tests.erl
│ │ │ ├── self_exits.erl
│ │ │ ├── send_after.erl
│ │ │ ├── send_after_trouble.erl
│ │ │ ├── send_named_vs_send.erl
│ │ │ ├── send_receive_dependencies.erl
│ │ │ ├── send_self.erl
│ │ │ ├── send_using_names.erl
│ │ │ ├── send_vs_trap_exit.erl
│ │ │ ├── signals_vs_messages.erl
│ │ │ ├── simple_ets.erl
│ │ │ ├── simple_spawn.erl
│ │ │ ├── sleep_set_block_not_bad.erl
│ │ │ ├── spawn_and_send.erl
│ │ │ ├── spawn_bad.erl
│ │ │ ├── spawn_failure.erl
│ │ │ ├── spawn_monitor_test.erl
│ │ │ ├── spawned_sender_crasher.erl
│ │ │ ├── spawned_senders.erl
│ │ │ ├── stacktrace_vs_exit.erl
│ │ │ ├── system_info.erl
│ │ │ ├── system_instant_delivery.erl
│ │ │ ├── system_non_instant_delivery.erl
│ │ │ ├── timers_afters_exits_crashes.erl
│ │ │ ├── timestamps.erl
│ │ │ ├── trace_the_sender.erl
│ │ │ ├── transparent_instrumentation.erl
│ │ │ ├── trigger_the_after.erl
│ │ │ ├── unregister_deadlocked.erl
│ │ │ ├── unsupported_exit.erl
│ │ │ └── waiting.erl
│ │ ├── bounding_tests/
│ │ │ ├── results/
│ │ │ │ ├── manolis-test_2workers_small-1-bpor-source.txt
│ │ │ │ ├── readers-test-0-dpor.txt
│ │ │ │ ├── readers-test-1-dpor.txt
│ │ │ │ ├── readers-test-2-dpor.txt
│ │ │ │ ├── readers-test-3-dpor.txt
│ │ │ │ ├── readers-test-4-dpor.txt
│ │ │ │ ├── readers-test-5-dpor.txt
│ │ │ │ ├── readers-test-6-dpor.txt
│ │ │ │ ├── readers-test-7-dpor.txt
│ │ │ │ ├── readers_2-test-0-dpor.txt
│ │ │ │ ├── readers_2-test-1-dpor.txt
│ │ │ │ ├── readers_2-test-2-dpor.txt
│ │ │ │ ├── readers_2-test-3-dpor.txt
│ │ │ │ ├── readers_2-test-4-dpor.txt
│ │ │ │ ├── readers_2-test-5-dpor.txt
│ │ │ │ ├── readers_2-test-6-dpor.txt
│ │ │ │ ├── readers_2-test-7-dpor.txt
│ │ │ │ ├── readers_compare-test-0-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-0-bpor-source.txt
│ │ │ │ ├── readers_compare-test-0-optimal.txt
│ │ │ │ ├── readers_compare-test-0-persistent.txt
│ │ │ │ ├── readers_compare-test-0-source.txt
│ │ │ │ ├── readers_compare-test-1-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-1-bpor-source.txt
│ │ │ │ ├── readers_compare-test-1-optimal.txt
│ │ │ │ ├── readers_compare-test-1-persistent.txt
│ │ │ │ ├── readers_compare-test-1-source.txt
│ │ │ │ ├── readers_compare-test-2-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-2-bpor-source.txt
│ │ │ │ ├── readers_compare-test-2-optimal.txt
│ │ │ │ ├── readers_compare-test-2-persistent.txt
│ │ │ │ ├── readers_compare-test-2-source.txt
│ │ │ │ ├── readers_compare-test-6-bpor-persistent.txt
│ │ │ │ ├── readers_compare-test-6-bpor-source.txt
│ │ │ │ ├── readers_compare-test-6-optimal.txt
│ │ │ │ ├── readers_compare-test-6-persistent.txt
│ │ │ │ ├── readers_compare-test-6-source.txt
│ │ │ │ ├── readers_delay-test-0-nodpor.txt
│ │ │ │ ├── readers_delay-test-1-nodpor.txt
│ │ │ │ ├── readers_delay-test-2-nodpor.txt
│ │ │ │ ├── readers_delay-test-3-nodpor.txt
│ │ │ │ ├── readers_delay-test-4-nodpor.txt
│ │ │ │ ├── readers_delay-test-5-nodpor.txt
│ │ │ │ ├── readers_delay-test-6-nodpor.txt
│ │ │ │ ├── readers_no_preempt-test-0-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-0-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-0-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-0-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-0-source.txt
│ │ │ │ ├── readers_no_preempt-test-1-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-1-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-1-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-1-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-1-source.txt
│ │ │ │ ├── readers_no_preempt-test-2-bpor-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-2-bpor-source.txt
│ │ │ │ ├── readers_no_preempt-test-2-optimal.txt
│ │ │ │ ├── readers_no_preempt-test-2-persistent.txt
│ │ │ │ ├── readers_no_preempt-test-2-source.txt
│ │ │ │ ├── simple_delay-test-0-dpor.txt
│ │ │ │ ├── simple_delay-test-1-dpor.txt
│ │ │ │ ├── simple_delay-test-2-dpor.txt
│ │ │ │ ├── writers-test-0-dpor.txt
│ │ │ │ ├── writers-test-1-dpor.txt
│ │ │ │ ├── writers-test-2-dpor.txt
│ │ │ │ ├── writers-test-3-dpor.txt
│ │ │ │ ├── writers-test-4-dpor.txt
│ │ │ │ ├── writers-test-5-dpor.txt
│ │ │ │ ├── writers-test-6-dpor.txt
│ │ │ │ └── writers-test-7-dpor.txt
│ │ │ └── src/
│ │ │ ├── manolis/
│ │ │ │ ├── rush_hour.erl
│ │ │ │ ├── search.erl
│ │ │ │ └── test.erl
│ │ │ ├── readers.erl
│ │ │ ├── readers_2.erl
│ │ │ ├── readers_compare.erl
│ │ │ ├── readers_delay.erl
│ │ │ ├── readers_no_preempt.erl
│ │ │ ├── simple_delay.erl
│ │ │ └── writers.erl
│ │ ├── corner_tests/
│ │ │ ├── results/
│ │ │ │ └── deliver_exhaustive-test-inf-nodpor.txt
│ │ │ └── src/
│ │ │ └── deliver_exhaustive.erl
│ │ ├── dpor_tests/
│ │ │ ├── results/
│ │ │ │ ├── POPL_optimal_example-test-inf-dpor.txt
│ │ │ │ ├── POPL_optimal_example-test-inf-source.txt
│ │ │ │ ├── after_test-after_test-inf-dpor.txt
│ │ │ │ ├── after_test_reduced-after_test_reduced-inf-dpor.txt
│ │ │ │ ├── combination_lock_1-combination_lock_1-inf-dpor.txt
│ │ │ │ ├── combination_lock_1-combination_lock_1-inf-source.txt
│ │ │ │ ├── complete_test_1-complete_test_1-inf-dpor.txt
│ │ │ │ ├── complete_test_2-complete_test_2-inf-dpor.txt
│ │ │ │ ├── conditional_readers-conditional_readers-inf-dpor.txt
│ │ │ │ ├── conditional_readers_2-conditional_readers_2-inf-dpor.txt
│ │ │ │ ├── conditional_readers_3-conditional_readers_3-inf-dpor.txt
│ │ │ │ ├── depend_1-depend_1-inf-dpor.txt
│ │ │ │ ├── depend_2-depend_2-inf-dpor.txt
│ │ │ │ ├── depend_3-depend_3-inf-dpor.txt
│ │ │ │ ├── depend_4-depend_4-inf-dpor.txt
│ │ │ │ ├── depend_4_screen-depend_4_screen-inf-dpor.txt
│ │ │ │ ├── depend_5-depend_5-inf-dpor.txt
│ │ │ │ ├── depend_6-depend_6-inf-dpor.txt
│ │ │ │ ├── depend_6_newest-test-inf-dpor.txt
│ │ │ │ ├── depend_6_round-test-inf-dpor.txt
│ │ │ │ ├── diff_dep_1-diff_dep_1-inf-dpor.txt
│ │ │ │ ├── diff_dep_2-diff_dep_2-inf-dpor.txt
│ │ │ │ ├── diff_dep_3-diff_dep_3-inf-dpor.txt
│ │ │ │ ├── diff_obs-test-inf-optimal.txt
│ │ │ │ ├── difficult_readers-difficult_readers-inf-dpor.txt
│ │ │ │ ├── ets_cross-test-inf-dpor.txt
│ │ │ │ ├── ets_dependencies-ets_dependencies-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_2-ets_dependencies_2-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_3-ets_dependencies_3-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_deeper-ets_dependencies_deeper-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_deeper_2-ets_dependencies_deeper_2-inf-dpor.txt
│ │ │ │ ├── ets_dependencies_n-ets_dependencies_n-inf-dpor.txt
│ │ │ │ ├── ets_writing_same-ets_writing_same-inf-dpor.txt
│ │ │ │ ├── etsi-etsi-inf-dpor.txt
│ │ │ │ ├── etsi_2-etsi_2-inf-dpor.txt
│ │ │ │ ├── etsi_3-etsi_3-inf-dpor.txt
│ │ │ │ ├── etsi_4-etsi_4-inf-dpor.txt
│ │ │ │ ├── etsi_5-etsi_5-inf-dpor.txt
│ │ │ │ ├── etsi_6-etsi_6-inf-dpor.txt
│ │ │ │ ├── etsi_7-etsi_7-inf-dpor.txt
│ │ │ │ ├── etsi_8-etsi_8-inf-dpor.txt
│ │ │ │ ├── file_system_example-test-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_1-hairbrush_teeth_1-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_2-hairbrush_teeth_2-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_3-hairbrush_teeth_3-inf-dpor.txt
│ │ │ │ ├── hairbrush_teeth_4-hairbrush_teeth_4-inf-dpor.txt
│ │ │ │ ├── independent_receivers-independent_receivers-inf-dpor.txt
│ │ │ │ ├── indifferent_senders-indifferent_senders-inf-dpor.txt
│ │ │ │ ├── last_zero-test-inf-dpor.txt
│ │ │ │ ├── last_zero-test-inf-source.txt
│ │ │ │ ├── long_chain-long_chain-inf-dpor.txt
│ │ │ │ ├── many_initials-many_initials-inf-dpor.txt
│ │ │ │ ├── many_kill_2-test-inf-dpor.txt
│ │ │ │ ├── manywrite-manywrite-inf-dpor.txt
│ │ │ │ ├── manywrite_2-manywrite_2-inf-dpor.txt
│ │ │ │ ├── messages_1-messages_1-inf-dpor.txt
│ │ │ │ ├── messages_2-test-inf-dpor.txt
│ │ │ │ ├── no_observers-test-inf-optimal.txt
│ │ │ │ ├── not_prerequisite_1-not_prerequisite_1-inf-dpor.txt
│ │ │ │ ├── observable_others-dep_obs-inf-optimal.txt
│ │ │ │ ├── observable_others-dep_unobs-inf-optimal.txt
│ │ │ │ ├── observable_others-indep_obs-inf-optimal.txt
│ │ │ │ ├── observable_others-indep_unobs-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_empty-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_flush-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_flush_info-inf-optimal.txt
│ │ │ │ ├── precise_demonitor-demonitor_info-inf-optimal.txt
│ │ │ │ ├── priorities-priorities-inf-dpor.txt
│ │ │ │ ├── process_info-links-inf-optimal.txt
│ │ │ │ ├── proxy-proxy-inf-dpor.txt
│ │ │ │ ├── proxy2-proxy2-inf-dpor.txt
│ │ │ │ ├── readers-test-inf-optimal.txt
│ │ │ │ ├── readers-test-inf-persistent.txt
│ │ │ │ ├── readers-test-inf-source.txt
│ │ │ │ ├── readers_basic-readers_basic-inf-dpor.txt
│ │ │ │ ├── readers_rrw-readers_rrw-inf-dpor.txt
│ │ │ │ ├── readers_rwr-readers_rwr-inf-dpor.txt
│ │ │ │ ├── readers_wrr-readers_wrr-inf-dpor.txt
│ │ │ │ ├── receive_order-test1-inf-dpor.txt
│ │ │ │ ├── receive_order-test2-inf-dpor.txt
│ │ │ │ ├── receive_order-test3-inf-dpor.txt
│ │ │ │ ├── register_again-register_again-inf-dpor.txt
│ │ │ │ ├── register_again_2-register_again_2-inf-dpor.txt
│ │ │ │ ├── same_messages-same_messages-inf-dpor.txt
│ │ │ │ ├── same_messages_2-same_messages_2-inf-dpor.txt
│ │ │ │ ├── same_messages_3-same_messages_3-inf-dpor.txt
│ │ │ │ ├── same_messages_4-same_messages_4-inf-dpor.txt
│ │ │ │ ├── send_it_ets-send_it_ets-inf-dpor.txt
│ │ │ │ ├── sleeping_races_1-sleeping_races_1-inf-dpor.txt
│ │ │ │ ├── sleeping_races_2-sleeping_races_2-inf-dpor.txt
│ │ │ │ ├── sleeping_races_3_read-sleeping_races_3_read-inf-dpor.txt
│ │ │ │ ├── sleeping_races_3_write-sleeping_races_3_write-inf-dpor.txt
│ │ │ │ ├── sleeping_races_4-sleeping_races_4-inf-dpor.txt
│ │ │ │ ├── sleeping_races_5-sleeping_races_5-inf-dpor.txt
│ │ │ │ ├── sleeping_races_6-sleeping_races_6-inf-dpor.txt
│ │ │ │ ├── sleeping_races_6-sleeping_races_6-inf-source.txt
│ │ │ │ ├── sleeping_races_7-sleeping_races_7-inf-dpor.txt
│ │ │ │ ├── sleeping_races_8-sleeping_races_8-inf-dpor.txt
│ │ │ │ ├── stress-stress-inf-dpor.txt
│ │ │ │ ├── sync_start-sync_start-inf-dpor.txt
│ │ │ │ ├── test_after_spawns-test_after_spawns-inf-dpor.txt
│ │ │ │ ├── timer_replayed-test-inf-dpor.txt
│ │ │ │ ├── tricky_predecessors-tricky_predecessors-inf-dpor.txt
│ │ │ │ ├── two_writers_readers_1-two_writers_readers_1-inf-dpor.txt
│ │ │ │ ├── two_writers_readers_2-two_writers_readers_2-inf-dpor.txt
│ │ │ │ ├── wakeup_many-wakeup_many-inf-dpor.txt
│ │ │ │ ├── workers-workers-inf-dpor.txt
│ │ │ │ ├── workers_2-workers_2-inf-dpor.txt
│ │ │ │ └── writeread-writeread-inf-dpor.txt
│ │ │ └── src/
│ │ │ ├── POPL_optimal_example.erl
│ │ │ ├── after_test.erl
│ │ │ ├── after_test_reduced.erl
│ │ │ ├── combination_lock_1.erl
│ │ │ ├── complete_test_1.erl
│ │ │ ├── complete_test_2.erl
│ │ │ ├── conditional_readers.erl
│ │ │ ├── conditional_readers_2.erl
│ │ │ ├── conditional_readers_3.erl
│ │ │ ├── depend_1.erl
│ │ │ ├── depend_2.erl
│ │ │ ├── depend_3.erl
│ │ │ ├── depend_4.erl
│ │ │ ├── depend_4_screen.erl
│ │ │ ├── depend_5.erl
│ │ │ ├── depend_6.erl
│ │ │ ├── depend_6_newest.erl
│ │ │ ├── depend_6_round.erl
│ │ │ ├── diff_dep_1.erl
│ │ │ ├── diff_dep_2.erl
│ │ │ ├── diff_dep_3.erl
│ │ │ ├── diff_obs.erl
│ │ │ ├── difficult_readers.erl
│ │ │ ├── ets_cross.erl
│ │ │ ├── ets_dependencies.erl
│ │ │ ├── ets_dependencies_2.erl
│ │ │ ├── ets_dependencies_3.erl
│ │ │ ├── ets_dependencies_deeper.erl
│ │ │ ├── ets_dependencies_deeper_2.erl
│ │ │ ├── ets_dependencies_n.erl
│ │ │ ├── ets_writing_same.erl
│ │ │ ├── etsi.erl
│ │ │ ├── etsi_2.erl
│ │ │ ├── etsi_3.erl
│ │ │ ├── etsi_4.erl
│ │ │ ├── etsi_5.erl
│ │ │ ├── etsi_6.erl
│ │ │ ├── etsi_7.erl
│ │ │ ├── etsi_8.erl
│ │ │ ├── file_system_example.erl
│ │ │ ├── hairbrush_teeth_1.erl
│ │ │ ├── hairbrush_teeth_2.erl
│ │ │ ├── hairbrush_teeth_3.erl
│ │ │ ├── hairbrush_teeth_4.erl
│ │ │ ├── independent_receivers.erl
│ │ │ ├── indifferent_senders.erl
│ │ │ ├── last_zero.erl
│ │ │ ├── long_chain.erl
│ │ │ ├── many_initials.erl
│ │ │ ├── many_kill_2.erl
│ │ │ ├── manywrite.erl
│ │ │ ├── manywrite_2.erl
│ │ │ ├── messages_1.erl
│ │ │ ├── messages_2.erl
│ │ │ ├── no_observers.erl
│ │ │ ├── not_prerequisite_1.erl
│ │ │ ├── observable_others.erl
│ │ │ ├── precise_demonitor.erl
│ │ │ ├── priorities.erl
│ │ │ ├── process_info.erl
│ │ │ ├── proxy.erl
│ │ │ ├── proxy2.erl
│ │ │ ├── readers.erl
│ │ │ ├── readers_basic.erl
│ │ │ ├── readers_rrw.erl
│ │ │ ├── readers_rwr.erl
│ │ │ ├── readers_wrr.erl
│ │ │ ├── receive_order.erl
│ │ │ ├── register_again.erl
│ │ │ ├── register_again_2.erl
│ │ │ ├── same_messages.erl
│ │ │ ├── same_messages_2.erl
│ │ │ ├── same_messages_3.erl
│ │ │ ├── same_messages_4.erl
│ │ │ ├── send_it_ets.erl
│ │ │ ├── sleeping_races_1.erl
│ │ │ ├── sleeping_races_2.erl
│ │ │ ├── sleeping_races_3_read.erl
│ │ │ ├── sleeping_races_3_write.erl
│ │ │ ├── sleeping_races_4.erl
│ │ │ ├── sleeping_races_5.erl
│ │ │ ├── sleeping_races_6.erl
│ │ │ ├── sleeping_races_7.erl
│ │ │ ├── sleeping_races_8.erl
│ │ │ ├── stress.erl
│ │ │ ├── sync_start.erl
│ │ │ ├── test_after_spawns.erl
│ │ │ ├── timer_replayed.erl
│ │ │ ├── tricky_predecessors.erl
│ │ │ ├── two_writers_readers_1.erl
│ │ │ ├── two_writers_readers_2.erl
│ │ │ ├── wakeup_many.erl
│ │ │ ├── workers.erl
│ │ │ ├── workers_2.erl
│ │ │ └── writeread.erl
│ │ └── erlang_tests/
│ │ ├── results/
│ │ │ ├── erlang_maps-maps_fold-inf-optimal.txt
│ │ │ ├── erlang_timer-cancel_bad-inf-optimal.txt
│ │ │ ├── erlang_timer-cancel_badarg-inf-optimal.txt
│ │ │ ├── erlang_timer-read_bad-inf-optimal.txt
│ │ │ └── erlang_timer-read_badarg-inf-optimal.txt
│ │ └── src/
│ │ ├── erlang_maps.erl
│ │ └── erlang_timer.erl
│ ├── test_template.erl
│ └── test_template_stripped.erl
└── tests-real/
├── Makefile
├── README.md
└── suites/
├── check_version.escript
├── erlang-litmus/
│ ├── .gitignore
│ ├── Makefile
│ ├── run_litmus.escript
│ └── test
├── makefile/
│ ├── Makefile
│ └── makefile-tests
├── options/
│ ├── .gitignore
│ ├── Makefile
│ ├── autocomplete/
│ │ ├── autocomplete.sh
│ │ ├── autocomplete_common.erl
│ │ ├── autocomplete_help.erl
│ │ ├── autocomplete_long.erl
│ │ └── autocomplete_short.erl
│ ├── autocomplete-tests
│ ├── footer
│ ├── header
│ ├── option1-tests
│ ├── option2-tests
│ ├── option3-tests
│ ├── other-tests
│ └── src/
│ ├── bad.erl
│ ├── bad_attribute.erl
│ ├── bad_attribute_1.erl
│ ├── bad_attribute_2.erl
│ ├── bad_attribute_3.erl
│ ├── bad_attribute_4.erl
│ ├── bad_attribute_5.erl
│ ├── debug_works.erl
│ ├── eunit_sample.erl
│ ├── excluded.erl
│ ├── excluding.erl
│ ├── first_and_other_deadlock.erl
│ ├── foo.erl
│ ├── from_shell.erl
│ ├── load_nif.erl
│ ├── other_deadlock.erl
│ └── six.erl
├── output/
│ ├── Makefile
│ ├── output-tests
│ ├── ref/
│ │ └── graph.dot
│ └── src/
│ ├── a_fun.erl
│ ├── buggy.erl
│ ├── deadlock.erl
│ ├── fig3.1-ext.erl
│ ├── harmless_exit.erl
│ ├── many_scheds.erl
│ ├── more_stacktrace.erl
│ ├── race_info.erl
│ ├── register.erl
│ └── stacktrace.erl
└── print_colors
SYMBOL INDEX (3 symbols across 1 files) FILE: tests/runtests.py function runTest (line 14) | def runTest(test): function runScenario (line 64) | def runScenario(suite, name, modn, funn, preb, flags, files): function equalResults (line 155) | def equalResults(suite, name, orig, rslt):
Copy disabled (too large)
Download .json
Condensed preview — 1282 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (14,374K chars).
[
{
"path": ".editorconfig",
"chars": 287,
"preview": "\n\n# EditorConfig is awesome: https://EditorConfig.org\n\n# top-most EditorConfig file\nroot = true\n\n# Unix-style newlines w"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 618,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\n\n---\n\n**Describe the bug**\nA clear and concise descriptio"
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"chars": 560,
"preview": "---\nname: Feature request\nabout: Suggest an idea for this project\n\n---\n\n**Is your feature request related to a problem? "
},
{
"path": ".github/ISSUE_TEMPLATE/other-issue.md",
"chars": 974,
"preview": "---\nname: Other Issue\nabout: An issue that is not a bug report or feature request\n\n---\n\nPlease think about the following"
},
{
"path": ".github/codecov.yml",
"chars": 230,
"preview": "codecov:\n notify:\n after_n_builds: 4\ncomment:\n after_n_builds: 4\ncoverage:\n status:\n project:\n default:\n "
},
{
"path": ".github/pull_request_template.md",
"chars": 201,
"preview": "## Summary\n\nDescribe what will be improved after merging this Pull Request.\n\n## Checklist\n\n* [ ] Has tests (or doesn't n"
},
{
"path": ".github/scripts/covertool_combine",
"chars": 235,
"preview": "#!/usr/bin/env bash\nset -euo pipefail\n\nEBIN=$(rebar3 path --ebin --app concuerror)\ncd cover\nexport COVER_COMBINE=all.cov"
},
{
"path": ".github/scripts/covertool_setup",
"chars": 158,
"preview": "#!/usr/bin/env bash\nset -euo pipefail\n\nmake cover/data\ncd cover\ngit clone https://github.com/covertool/covertool.git --b"
},
{
"path": ".github/workflows/tests.yml",
"chars": 2938,
"preview": "name: Tests\n\non:\n push:\n branches: master\n pull_request:\n branches: master\n paths-ignore:\n - 'docs/**'\n "
},
{
"path": ".github/workflows/website.yml",
"chars": 610,
"preview": "name: Website\n\non:\n push:\n branches: master\n paths: 'docs/**'\n pull_request:\n branches: master\n paths: 'do"
},
{
"path": ".gitignore",
"chars": 235,
"preview": "# NOTE! Please use 'git ls-files -i --exclude-standard'\n# command after changing this file, to see if there are\n# any tr"
},
{
"path": "CHANGELOG.md",
"chars": 2787,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3229,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 2759,
"preview": "# How to contribute to Concuerror\n\nFirst of all, thank you for taking time to contribute to Concuerror!\n\nIf you don't kn"
},
{
"path": "LICENSE",
"chars": 1398,
"preview": " Copyright (c) 2014-2018, Stavros Aronis (<aronisstav@gmail.com>) and Kostis Sagonas (<kostis@cs.ntua.gr>).\n All right"
},
{
"path": "Makefile",
"chars": 3274,
"preview": "###-----------------------------------------------------------------------------\n### Application info\n###---------------"
},
{
"path": "README.md",
"chars": 2226,
"preview": "[![Hex Docs][hex badge]][hex]\n[![Tests][tests badge]][tests]\n[![Codecov][codecov badge]][codecov]\n\n# Concuerror\n\nConcuer"
},
{
"path": "bin/.gitignore",
"chars": 11,
"preview": "concuerror\n"
},
{
"path": "cover/.gitignore",
"chars": 40,
"preview": "*.coverdata\n*.COVER.html\ncovertool\ndata\n"
},
{
"path": "cover/cover-report",
"chars": 2220,
"preview": "#!/usr/bin/env escript\n%%! +S1 -nostick -noshell -pa ../_build/default/lib/concuerror/ebin\n\nmain([CoverDir]) ->\n {ok, F"
},
{
"path": "doc/.gitignore",
"chars": 61,
"preview": "*_option.edoc\n*.css\n*.html\nedoc-info\nerlang.png\nGemfile.lock\n"
},
{
"path": "doc/Gemfile",
"chars": 50,
"preview": "source 'https://rubygems.org'\n\ngem \"html-proofer\"\n"
},
{
"path": "doc/Makefile",
"chars": 391,
"preview": ".PHONY: default\ndefault: build\n\nGemfile.lock: Gemfile\n\tbundle install\n\ttouch $@\n\n.PHONY: build\nbuild:\n\tmake -C .. edoc\n\n"
},
{
"path": "doc/overview.edoc",
"chars": 1694,
"preview": "@title Concuerror's API specification\n@doc\n\n== Welcome! ==\n\nThis documentation contains Concuerror's API specification. "
},
{
"path": "docs/.bundle/config",
"chars": 33,
"preview": "---\nBUNDLE_PATH: \"vendor/bundle\"\n"
},
{
"path": "docs/.gitignore",
"chars": 28,
"preview": "/_site\n.jekyll-cache\nvendor\n"
},
{
"path": "docs/404.md",
"chars": 172,
"preview": "---\nlayout: search\ntitle: \"Page Not Found\"\ndescription: \"Page not found\"\n--- \n\n## 404 Error\n\nSorry, but the page you we"
},
{
"path": "docs/CNAME",
"chars": 14,
"preview": "concuerror.com"
},
{
"path": "docs/Gemfile",
"chars": 107,
"preview": "source 'https://rubygems.org'\n\ngem \"github-pages\", group: :jekyll_plugins\ngem \"html-proofer\"\ngem \"webrick\"\n"
},
{
"path": "docs/Makefile",
"chars": 475,
"preview": ".PHONY: default\ndefault: build\n\nJEKYLL = bundle exec jekyll\nPROOFER = bundle exec htmlproofer ./_site --checks \"Images,L"
},
{
"path": "docs/README.md",
"chars": 137,
"preview": "# Concuerror's Website\n\nBased on the [**So Simple Theme**](http://mmistakes.github.io)\n\n## How to build\n\n`bundle install"
},
{
"path": "docs/_config.yml",
"chars": 1710,
"preview": "# Base config\ntitle: \"Concuerror\"\ndescription: \"Concuerror is a model checking tool for debugging, testing and verifying"
},
{
"path": "docs/_config_local.yml",
"chars": 8,
"preview": "url: \"\"\n"
},
{
"path": "docs/_data/authors.yml",
"chars": 358,
"preview": "stavros:\n name: Stavros Aronis\n picture: https://www.gravatar.com/avatar/5730e85681def67cb10151437519f39d?s=200\n emai"
},
{
"path": "docs/_data/navigation.yml",
"chars": 715,
"preview": "- title: <i class=\"fas fa-home\"></i> Home\n url: /\n- title: <i class=\"fas fa-newspaper\"></i> News\n url: /news\n- title: "
},
{
"path": "docs/_data/text.yml",
"chars": 4730,
"preview": "# Theme text and labels\n\n\n# English (default)\n# -----------------\nen: &DEFAULT_EN\n skip_links: \"Skip links\"\n skip_prim"
},
{
"path": "docs/_includes/footer-custom.html",
"chars": 238,
"preview": "<div class=\"small\">{% if page.updated %}Page last modified on {{ page.updated | date: site.date_format }} | {% endif %}<"
},
{
"path": "docs/_includes/head-custom.html",
"chars": 74,
"preview": "<link rel=\"shortcut icon\" href=\"/images/favicon.ico\" type=\"image/x-icon\">\n"
},
{
"path": "docs/_includes/masthead.html",
"chars": 401,
"preview": "<header class=\"masthead\">\n <div class=\"wrap\">\n {% if site.logo %}\n <a href=\"{{ '/' | relative_url }}\" class=\"si"
},
{
"path": "docs/_includes/yt.html",
"chars": 222,
"preview": "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/{{ yt-link }}\" frameborder=\"0\" allow=\"accelerometer;"
},
{
"path": "docs/_posts/2013-09-03-site.md",
"chars": 124,
"preview": "---\nlayout: post\ntitle: \"Concuerror's website\"\ncategory: news\nredirect_from: /site.html\n---\n\nConcuerror just got a websi"
},
{
"path": "docs/_posts/2013-09-23-euc-2013.md",
"chars": 489,
"preview": "---\nlayout: post\ntitle: \"Tutorial at EUC 2013: Video and Slides\"\nauthor: Kostis Sagonas\ncategory: tutorials\n---\n\nKostis "
},
{
"path": "docs/_posts/2014-06-02-poolboy-example.md",
"chars": 8244,
"preview": "---\nlayout: post\ntitle: \"Concuerror basics (Testing Poolboy, Part 1)\"\ncategory: tutorials\nupdated: 2018-03-21\n---\n\nIn th"
},
{
"path": "docs/_posts/2014-06-03-poolboy-example-errors.md",
"chars": 8172,
"preview": "---\nlayout: post\ntitle: \"Reading Concuerror's reports (Testing Poolboy, Part 2)\"\ncategory: tutorials\nupdated: 2018-03-21"
},
{
"path": "docs/_posts/2014-08-11-euc-2014.md",
"chars": 808,
"preview": "---\nlayout: post\ntitle: \"Talk at EUC 2014: Video and Slides\"\nupdated: 2015-06-17\ncategory: news\nredirect_from: /euc-2014"
},
{
"path": "docs/_posts/2015-06-10-euc-2015.md",
"chars": 427,
"preview": "---\nlayout: post\ntitle: \"Tutorial at EUC 2015: Slides\"\ncategory: tutorials\nupdated: 2015-06-10\n---\n\nStavros Aronis is pr"
},
{
"path": "docs/_posts/2017-08-14-euc-2017-talk.md",
"chars": 449,
"preview": "---\nlayout: post\ntitle: \"Talk at EUC 2017: Video and Slides\"\ncategory: news\nredirect_from: /euc-2017-talk.html\n---\n\nKost"
},
{
"path": "docs/_posts/2017-08-14-euc-2017-tutorial.md",
"chars": 300,
"preview": "---\nlayout: post\ntitle: \"Tutorial at EUC 2017: Slides\"\ncategory: tutorials\n---\n\nStavros Aronis presented a tutorial on C"
},
{
"path": "docs/_posts/2017-10-03-publications-update.md",
"chars": 250,
"preview": "---\nlayout: post\ntitle: \"Recent Publications and Homepage\"\ncategory: news\nredirect_from: /publications-update.html\n---\n\n"
},
{
"path": "docs/_posts/2017-10-08-concuerror-eunit.md",
"chars": 8408,
"preview": "---\nlayout: post\ntitle: \"How to run Concuerror with EUnit\"\ncategory: tutorials\nupdated: 2018-03-09\n---\n\nHere are some gu"
},
{
"path": "docs/_posts/2017-10-14-concuerring-concuerror-ep-1.md",
"chars": 10222,
"preview": "---\nlayout: post\ntitle: \"Concuerring Concuerror\"\ncategory: tutorials\nredirect_from: /concuerring-concuerror-ep-1.html\n--"
},
{
"path": "docs/_posts/2017-11-06-Announcing-Mailing-List.md",
"chars": 164,
"preview": "---\nlayout: post\ntitle: \"Announcing a Mailing List\"\ncategory: news\nredirect_from: /Announcing-Mailing-List.html\n---\n\nCon"
},
{
"path": "docs/_posts/2018-07-15-hex.md",
"chars": 286,
"preview": "---\nlayout: post\ntitle: \"Available on Hex.pm (with API specification)\"\ncategory: news\nredirect_from: /hex.html\n---\n\nConc"
},
{
"path": "docs/_posts/2020-10-10-tips.md",
"chars": 6508,
"preview": "---\nlayout: post\ntitle: \"How to optimize Concuerror's search?\"\ncategory: news\nredirect_from: /tips.html\n---\n\n## Table of"
},
{
"path": "docs/_posts/2020-10-17-code-beam-sf-2019.md",
"chars": 388,
"preview": "---\nlayout: post\ntitle: \"Talk at CODE BEAM SF 2019: Slides\"\ncategory: news\nredirect_from: /code-beam-sf-2019.html\n---\n\nS"
},
{
"path": "docs/_posts/2020-10-17-functional-conf-2018.md",
"chars": 533,
"preview": "---\nlayout: post\ntitle: \"Talk at Functional Conf 2018: Video and Slides\"\ncategory: news\nredirect_from: /functional-conf-"
},
{
"path": "docs/_posts/2020-10-24-basic-tutorial.md",
"chars": 1912,
"preview": "---\nlayout: post\ncategory: tutorials\n---\n\nBefore you launch Concuerror, you need a test that is **terminating**\n(ideally"
},
{
"path": "docs/contact.md",
"chars": 762,
"preview": "---\nlayout: page\npermalink: /contact/index.html\ntitle: \"Contact\"\ndescription: \"Information about contacting Concuerror's"
},
{
"path": "docs/download.md",
"chars": 1090,
"preview": "---\nlayout: page\npermalink: /download/index.html\ntitle: \"Download Concuerror\"\ndescription: \"Information on how to downlo"
},
{
"path": "docs/faq.md",
"chars": 6812,
"preview": "---\nlayout: page\npermalink: /faq/index.html\ntitle: \"Concuerror's FAQ\"\ndescription: \"Concuerror's Frequently Asked Questi"
},
{
"path": "docs/feed.xml",
"chars": 1622,
"preview": "---\nlayout: null\n---\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<feed xmlns=\"http://www.w3.org/2005/Atom\" xml:lang=\"en\">\n<ti"
},
{
"path": "docs/index.md",
"chars": 2514,
"preview": "---\nlayout: page\nupdated: 2020-10-25\ndescription: \"Homepage of the Concuerror, a tool for debugging, testing and verifyi"
},
{
"path": "docs/news.md",
"chars": 150,
"preview": "---\nlayout: posts\npermalink: /news/index.html\ntitle: News\ndescription: \"Links to all posts on this website, sorted by da"
},
{
"path": "docs/publications.md",
"chars": 8310,
"preview": "---\nlayout: page\npermalink: /publications/index.html\ntitle: Publications\ndescription: \"Scientific publications regarding"
},
{
"path": "docs/search.md",
"chars": 110,
"preview": "---\nlayout: search\npermalink: /search/index.html\ntitle: Search\ndescription: \"Search Concuerror's website\"\n---\n"
},
{
"path": "docs/sitemap.xml",
"chars": 310,
"preview": "---\nlayout: null\n---\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">"
},
{
"path": "docs/tutorials.md",
"chars": 333,
"preview": "---\nlayout: category\npermalink: /tutorials/index.html\ntitle: Tutorials\ndescription: \"Links to tutorials on how to use Co"
},
{
"path": "elvis.config",
"chars": 1852,
"preview": "[{elvis, [{config,\n [ #{ dirs => [\"src\"]\n , filter => \"*.erl\"\n , rules =>\n [ {elvis_style, module_naming_co"
},
{
"path": "priv/concuerror",
"chars": 820,
"preview": "#!/usr/bin/env escript\n%%! +S1 -boot start_clean -noshell -pa . -pa ebin\n\n%% This script is used instead of the 'escript"
},
{
"path": "priv/generate_option_docfiles",
"chars": 138,
"preview": "#!/usr/bin/env escript\n%%! -noshell -pa _build/docs/lib/concuerror/ebin\n\nmain(Dir) ->\n concuerror_options:generate_opti"
},
{
"path": "priv/generate_version_hrl",
"chars": 742,
"preview": "#!/usr/bin/env escript\n%%! -noshell\n\n%% The expected argument is the latest OTP version supported by\n%% Concuerror.\nmain"
},
{
"path": "rebar.config",
"chars": 1456,
"preview": "{minimum_otp_vsn, \"20.0\"}.\n\n{erl_opts,\n [ debug_info\n , warn_export_vars\n , warn_unused_import\n , warn_missing_spec\n , w"
},
{
"path": "resources/DPOR_paper_material/DPOR_README",
"chars": 9086,
"preview": "Optimal Dynamic Partial Order Reduction for Analysis of Concurrent Programs\n--------------------------------------------"
},
{
"path": "resources/DPOR_paper_material/foo.erl",
"chars": 216,
"preview": "-module(foo).\n\n-export([foo/0]).\n\nfoo() ->\n P = self(),\n spawn(fun() -> P ! a end),\n spawn(fun() -> P ! b end),"
},
{
"path": "resources/DPOR_paper_material/foobar.erl",
"chars": 75,
"preview": "-module(foobar).\n\n-export([foo/0]).\n\nfoo() ->\n bar().\n\nbar() ->\n ok.\n"
},
{
"path": "resources/DPOR_paper_material/my_test.erl",
"chars": 348,
"preview": "-module(my_test).\n\n-export([test/1]).\n\ntest(small) ->\n foo_test();\ntest(large) ->\n foobar_test().\n\nfoo_test() ->\n "
},
{
"path": "resources/DPOR_paper_material/run_dialyzer.sh",
"chars": 488,
"preview": "#!/usr/bin/env bash\n\necho \"\\\\hline\"\nfor i in small large; do\n f=0\n for t in --dpor --dpor_source --dpor_classic; d"
},
{
"path": "resources/DPOR_paper_material/run_filesystem.sh",
"chars": 613,
"preview": "#!/usr/bin/env bash\n\nT=file_system_example\n\necho \"\\\\hline\"\nfor i in 16 18; do\n f=0\n for t in --dpor --dpor_source "
},
{
"path": "resources/DPOR_paper_material/run_indexer.sh",
"chars": 599,
"preview": "#!/usr/bin/env bash\n\nT=indexer_example\n\necho \"\\\\hline\"\nfor i in 12 15; do\n f=0\n for t in --dpor --dpor_source --dp"
},
{
"path": "resources/DPOR_paper_material/run_last_zero.sh",
"chars": 606,
"preview": "#!/usr/bin/env bash\n\nT=sleeping_races_8\n\necho \"\\\\hline\"\nfor i in 2 5 10; do\n f=0\n for t in --dpor --dpor_source --"
},
{
"path": "resources/DPOR_paper_material/run_readers.sh",
"chars": 587,
"preview": "#!/usr/bin/env bash\n\nT=readers\n\necho \"\\\\hline\"\nfor i in 2 8; do\n f=0\n for t in --dpor --dpor_source --dpor_classic"
},
{
"path": "resources/DPOR_paper_material/run_rush_hour.sh",
"chars": 633,
"preview": "#!/usr/bin/env bash\n\nT=rush_hour\n\necho \"\\\\hline\"\nfor i in -; do\n f=0\n for t in --dpor --dpor_source --dpor_classic"
},
{
"path": "resources/bash_completion/concuerror",
"chars": 2372,
"preview": "#!/bin/bash\n# bash_completion for concuerror\n\n# To use it, you can either:\n# - Link the file to e.g. `/etc/bash_completi"
},
{
"path": "resources/erlang_questions/dets_bugs/alt_dets_bugs.erl",
"chars": 2328,
"preview": "-module(alt_dets_bugs).\n\n-export([bug3/0, bug5/0, bug6/0]).\n\n-include_lib(\"eunit/include/eunit.hrl\").\n\n%% should always "
},
{
"path": "resources/erlang_questions/dets_bugs/dets_bugs.erl",
"chars": 2613,
"preview": "-module(dets_bugs).\n\n-export([bug1/0, bug2/0, bug3/0, bug4/0, bug5/0, bug6/0]).\n\n%% should always print a boolean, but s"
},
{
"path": "resources/flanagan.erl",
"chars": 12115,
"preview": "%% -*- erlang-indent-level: 2 -*-\n\n-module(flanagan).\n\n-export([test/1, explore/2]).\n\n%% -define(DEBUG, true).\n%% -defin"
},
{
"path": "resources/how-to-release.md",
"chars": 1060,
"preview": "# How to make a release\n\nHere is how to prepare a new release of Concuerror\n\n## Decide release number\n\nFollow semantic v"
},
{
"path": "resources/old_include/gen.hrl",
"chars": 3277,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_include/gui.hrl",
"chars": 6686,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_include/instr.hrl",
"chars": 5920,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2013, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/LICENSE",
"chars": 1480,
"preview": " Copyright (c) 2011, Alkis Gotovos <el3ctrologos@hotmail.com>,\n Maria Christakis <mchrista@softlab"
},
{
"path": "resources/old_source/concuerror.erl",
"chars": 24390,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2012, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_deps.erl",
"chars": 22382,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2013, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_error.erl",
"chars": 2907,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_gui.erl",
"chars": 53302,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_instr.erl",
"chars": 28395,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_io_server.erl",
"chars": 4139,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2012, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_lid.erl",
"chars": 6612,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_log.erl",
"chars": 5581,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_proc_action.erl",
"chars": 12272,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_rep.erl",
"chars": 38181,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_sched.erl",
"chars": 66155,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_state.erl",
"chars": 4197,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_ticket.erl",
"chars": 2829,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/old_source/concuerror_util.erl",
"chars": 10403,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/perm_tests/run_perm_tests",
"chars": 1794,
"preview": "#!/usr/bin/env bash\nMYNAME=$(basename $0)\n\nexport DIR=$(dirname $0)\n\nperm() {\n local items=\"$1\"\n local out=\"$2\"\n "
},
{
"path": "resources/perm_tests/src/complete_test_3.erl",
"chars": 1093,
"preview": "-module(complete_test_3).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"80\").\n\nprocs() -> io:format(\"6\")"
},
{
"path": "resources/perm_tests/src/conditional_readers_3.erl",
"chars": 728,
"preview": "-module(conditional_readers_3).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"6\").\n\nprocs() -> io:format"
},
{
"path": "resources/perm_tests/src/depend_4_1.erl",
"chars": 1061,
"preview": "-module(depend_4_1).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"30\").\n\nprocs() -> io:format(\"6\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_4_2.erl",
"chars": 976,
"preview": "-module(depend_4_2).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"20\").\n\nprocs() -> io:format(\"6\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_4_3.erl",
"chars": 773,
"preview": "-module(depend_4_3).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"16\").\n\nprocs() -> io:format(\"5\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_6_1.erl",
"chars": 702,
"preview": "-module(depend_6_1).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"18\").\n\nprocs() -> io:format(\"4\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_6_2.erl",
"chars": 702,
"preview": "-module(depend_6_2).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"27\").\n\nprocs() -> io:format(\"4\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_6_3.erl",
"chars": 702,
"preview": "-module(depend_6_3).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"36\").\n\nprocs() -> io:format(\"4\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_6_4.erl",
"chars": 702,
"preview": "-module(depend_6_4).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"18\").\n\nprocs() -> io:format(\"4\").\n\nru"
},
{
"path": "resources/perm_tests/src/depend_6_5.erl",
"chars": 676,
"preview": "-module(depend_6_5).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"12\").\n\nprocs() -> io:format(\"4\").\n\nru"
},
{
"path": "resources/perm_tests/src/etsi.erl",
"chars": 757,
"preview": "-module(etsi).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"7\").\n\nprocs() -> io:format(\"3\").\n\nrun(Procs"
},
{
"path": "resources/perm_tests/src/readers_2.erl",
"chars": 640,
"preview": "-module(readers_2).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"4\").\n\nprocs() -> io:format(\"3\").\n\nrun("
},
{
"path": "resources/perm_tests/src/readers_3.erl",
"chars": 666,
"preview": "-module(readers_3).\n\n-export([result/0, procs/0, run/1]).\n\nresult() -> io:format(\"8\").\n\nprocs() -> io:format(\"4\").\n\nrun("
},
{
"path": "resources/syntax/block_after.erl",
"chars": 534,
"preview": "%%%----------------------------------------------------------------------\n%%% File : block_after.erl\n%%% Authors "
},
{
"path": "resources/syntax/non_local_pat.erl",
"chars": 672,
"preview": "%%%----------------------------------------------------------------------\n%%% File : non_local_pat.erl\n%%% Author"
},
{
"path": "resources/syntax/rec_uscore.erl",
"chars": 562,
"preview": "%%%----------------------------------------------------------------------\n%%% File : rec_uscore.erl\n%%% Authors "
},
{
"path": "resources/syntax/strip_attr.erl",
"chars": 822,
"preview": "%%%----------------------------------------------------------------------\n%%% File : strip_attr.erl\n%%% Authors "
},
{
"path": "resources/tdd/reg_server.erl",
"chars": 3413,
"preview": "%%%----------------------------------------------------------------------\n%%% Author : Alkis Gotovos <alkisg@softla"
},
{
"path": "resources/tdd/reg_server.hrl",
"chars": 26,
"preview": "-define(MAX_ATTACHED, 2).\n"
},
{
"path": "resources/tdd/reg_server_tests.erl",
"chars": 4792,
"preview": "%%%----------------------------------------------------------------------\n%%% Author : Alkis Gotovos <alkisg@softla"
},
{
"path": "resources/utest/concuerror_error_tests.erl",
"chars": 2557,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/utest/concuerror_instr_tests.erl",
"chars": 2210,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/utest/concuerror_lid_tests.erl",
"chars": 3127,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/utest/concuerror_state_tests.erl",
"chars": 1753,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "resources/utest/concuerror_ticket_tests.erl",
"chars": 1675,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2011, Alkis Gotovos <el3ctro"
},
{
"path": "src/.gitignore",
"chars": 27,
"preview": "concuerror_otp_version.hrl\n"
},
{
"path": "src/concuerror.app.src",
"chars": 410,
"preview": "{application, concuerror,\n [ {description,\n \"Concuerror: Stateless Model Checking tool for Erlang programs\"\n }\n , {"
},
{
"path": "src/concuerror.erl",
"chars": 6460,
"preview": "%%% @doc\n%%% Concuerror's main module\n%%%\n%%% Contains the entry points for invoking Concuerror, either directly\n%%% fro"
},
{
"path": "src/concuerror.hrl",
"chars": 7149,
"preview": "-include(\"concuerror_otp_version.hrl\").\n\n%%-----------------------------------------------------------------------------"
},
{
"path": "src/concuerror_callback.erl",
"chars": 89419,
"preview": "%%% @private\n%%% @doc\n%%% This module contains code for:\n%%% - managing and interfacing with processes under Concuerror\n"
},
{
"path": "src/concuerror_dependencies.erl",
"chars": 31671,
"preview": "%%% @private\n-module(concuerror_dependencies).\n\n-export([dependent/3, dependent_safe/2, explain_error/1]).\n\n-export_type"
},
{
"path": "src/concuerror_estimator.erl",
"chars": 10589,
"preview": "%%% @private\n%%% @doc\n%%% The estimator process is being updated by the scheduler and polled\n%%% independently by the lo"
},
{
"path": "src/concuerror_inspect.erl",
"chars": 3020,
"preview": "%%% @private\n%%% @doc\n%%% The instrumenter replaces interesting operations with calls\n%%% to inspect/3\n-module(concuerro"
},
{
"path": "src/concuerror_instrumenter.erl",
"chars": 7747,
"preview": "%%% @private\n-module(concuerror_instrumenter).\n\n-export([instrument/3]).\n\n-define(inspect, concuerror_inspect).\n\n-define"
},
{
"path": "src/concuerror_io_lib.erl",
"chars": 5768,
"preview": "%%% @private\n-module(concuerror_io_lib).\n\n-export([error_s/2, pretty/3, pretty_s/2]).\n\n-include(\"concuerror.hrl\").\n\n-spe"
},
{
"path": "src/concuerror_loader.erl",
"chars": 5861,
"preview": "%%% @private\n-module(concuerror_loader).\n\n-export([initialize/1, load/1, load_initially/1, is_instrumenting/0]).\n\n%%----"
},
{
"path": "src/concuerror_logger.erl",
"chars": 33838,
"preview": "%%% @private\n%%% @doc\n%%% The logger is a process responsible for collecting information and\n%%% sending output to the u"
},
{
"path": "src/concuerror_options.erl",
"chars": 62834,
"preview": "%%% @doc\n%%% Concuerror's options module\n%%%\n%%% The `_option()' functions listed on this page all correspond to\n%%% val"
},
{
"path": "src/concuerror_scheduler.erl",
"chars": 68333,
"preview": "%%% @private\n%%% @doc Concuerror's scheduler component\n%%%\n%%% concuerror_scheduler is the main driver of interleaving\n%"
},
{
"path": "src/concuerror_window_average.erl",
"chars": 1343,
"preview": "%%% @private\n%%% @doc\n%%% This module provides functions for calculating a running\n%%% window average of numerical value"
},
{
"path": "test/README.md",
"chars": 130,
"preview": "# Concuerror's EUnit tests\n\nThis directory contains tests that can be run by Rebar,\ne.g. `rebar3 eunit` (from the top di"
},
{
"path": "test/concuerror_logger_tests.erl",
"chars": 5353,
"preview": "-module(concuerror_logger_tests).\n\n-include_lib(\"eunit/include/eunit.hrl\").\n\n-define(M, concuerror_logger).\n\n%%========="
},
{
"path": "test/concuerror_options_tests.erl",
"chars": 583,
"preview": "-module(concuerror_options_tests).\n\n-include_lib(\"eunit/include/eunit.hrl\").\n\n-define(M, concuerror_options).\n\n%%======="
},
{
"path": "tests/README.md",
"chars": 2827,
"preview": "# Concuerror's 'output comparison' testsuite\n\n## Structure\n\nThis testsuite contains a number of **suites**, each\ncontain"
},
{
"path": "tests/differ",
"chars": 488,
"preview": "#!/usr/bin/env bash\n\nset -o pipefail\n\nDIFFPRINTER=${DIFFPRINTER:-thediff}\n\nDIFF=$(mktemp)\n\ndiff \\\n <(grep \" Summary\""
},
{
"path": "tests/results/.gitignore",
"chars": 14,
"preview": "*\n!.gitignore\n"
},
{
"path": "tests/runtests.py",
"chars": 7072,
"preview": "#!/usr/bin/env python3\n\nimport os\nimport re\nimport sys\nimport glob\nimport subprocess\nfrom ctypes import c_int\nfrom multi"
},
{
"path": "tests/scenarios.erl",
"chars": 2010,
"preview": "%%%----------------------------------------------------------------------\n%%% Copyright (c) 2012, Alkis Gotovos <el3ctro"
},
{
"path": "tests/suites/advanced_tests/results/gen_server_bug-test_register-inf-dpor.txt",
"chars": 6039,
"preview": "Concuerror 0.20.0+build.2156.refc966f32 started at 15 Aug 2018 12:13:24\n Options:\n [{after_timeout,infinity},\n {asser"
},
{
"path": "tests/suites/advanced_tests/results/gen_server_bug-test_without_register-inf-dpor.txt",
"chars": 2071,
"preview": "Concuerror 0.20.0+build.2156.refc966f32 started at 15 Aug 2018 12:13:24\n Options:\n [{after_timeout,infinity},\n {asser"
},
{
"path": "tests/suites/advanced_tests/results/manolis-test_2workers_small-inf-dpor.txt",
"chars": 1597,
"preview": "################################################################################\n\nConcuerror started with options:\n [{a"
},
{
"path": "tests/suites/advanced_tests/results/percept-test-inf-dpor.txt",
"chars": 877287,
"preview": "Concuerror v0.19+build.2106.ref7648ae2 started at 09 Jul 2018 18:17:44\n Options:\n [{after_timeout,infinity},\n {assert"
},
{
"path": "tests/suites/advanced_tests/results/preemption-preemption-inf-dpor.txt",
"chars": 10907,
"preview": "Concuerror v0.17 ('47c15d4') started at 15 Sep 2017 13:29:33\n Options:\n [{after_timeout,infinity},\n {assertions_only,"
},
{
"path": "tests/suites/advanced_tests/results/receive_deps-test-inf-dpor.txt",
"chars": 89352,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/receive_deps_kill-test-inf-dpor.txt",
"chars": 13792,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/receive_pats-test1-inf-dpor.txt",
"chars": 1405,
"preview": "Concuerror 0.17 ('17d5365') started at 18 Apr 2017 16:18:24\n Options:\n [{after_timeout,infinity},\n {assertions_only,f"
},
{
"path": "tests/suites/advanced_tests/results/receive_pats-test2-inf-dpor.txt",
"chars": 1405,
"preview": "Concuerror 0.17 ('17d5365') started at 18 Apr 2017 16:18:24\n Options:\n [{after_timeout,infinity},\n {assertions_only,f"
},
{
"path": "tests/suites/advanced_tests/results/receive_pats-test3-inf-dpor.txt",
"chars": 1405,
"preview": "Concuerror 0.17 ('17d5365') started at 18 Apr 2017 16:18:24\n Options:\n [{after_timeout,infinity},\n {assertions_only,f"
},
{
"path": "tests/suites/advanced_tests/results/receive_pats-test4-inf-dpor.txt",
"chars": 1405,
"preview": "Concuerror 0.17 ('17d5365') started at 18 Apr 2017 16:18:25\n Options:\n [{after_timeout,infinity},\n {assertions_only,f"
},
{
"path": "tests/suites/advanced_tests/results/receive_patterns-test1-inf-optimal.txt",
"chars": 1784,
"preview": "Concuerror v0.17 ('62ab815') started at 14 Sep 2017 14:05:57\n Options:\n [{after_timeout,infinity},\n {assertions_only,"
},
{
"path": "tests/suites/advanced_tests/results/receive_patterns-test2-inf-optimal.txt",
"chars": 1784,
"preview": "Concuerror v0.17 ('62ab815') started at 14 Sep 2017 14:05:56\n Options:\n [{after_timeout,infinity},\n {assertions_only,"
},
{
"path": "tests/suites/advanced_tests/results/ring_leader_election-ring_leader_election-inf-dpor.txt",
"chars": 1448,
"preview": "Concuerror v0.17 (fa28363) started at 19 Sep 2017 11:43:25\n Options:\n [{after_timeout,infinity},\n {assertions_only,fa"
},
{
"path": "tests/suites/advanced_tests/results/ring_leader_election_barrier-ring_leader_election_barrier-inf-dpor.txt",
"chars": 1496,
"preview": "Concuerror v0.17 (fa28363) started at 19 Sep 2017 11:46:02\n Options:\n [{after_timeout,infinity},\n {assertions_only,fa"
},
{
"path": "tests/suites/advanced_tests/results/ring_leader_election_symmetric-ring_leader_election_symmetric-inf-dpor.txt",
"chars": 702,
"preview": "################################################################################\nConcuerror started with options:\n [{'a"
},
{
"path": "tests/suites/advanced_tests/results/ring_leader_election_symmetric_buffer-ring_leader_election_symmetric_buffer-inf-dpor.txt",
"chars": 369541,
"preview": "################################################################################\nConcuerror started with options:\n [{'a"
},
{
"path": "tests/suites/advanced_tests/results/ring_leader_election_symmetric_buffer_2-ring_leader_election_symmetric_buffer_2-inf-dpor.txt",
"chars": 375563,
"preview": "################################################################################\nConcuerror started with options:\n [{'a"
},
{
"path": "tests/suites/advanced_tests/results/shared_ptr-shared_ptr-inf-dpor.txt",
"chars": 1072,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/shootout-test1-inf-dpor.txt",
"chars": 1217,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/simple_registry-simple_registry-inf-dpor.txt",
"chars": 1528,
"preview": "Concuerror v0.17 ('189e1f0') started at 19 Sep 2017 17:49:54\n Options:\n [{after_timeout,infinity},\n {assertions_only,"
},
{
"path": "tests/suites/advanced_tests/results/source_killer-test-inf-dpor.txt",
"chars": 10860,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/source_killer-test-inf-source.txt",
"chars": 9646,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/results/vjeko_peer-concuerror_test-inf-dpor.txt",
"chars": 1440,
"preview": "################################################################################\nConcuerror started with options:\n [{af"
},
{
"path": "tests/suites/advanced_tests/src/gen_server_bug.erl",
"chars": 1385,
"preview": "-module(gen_server_bug).\r\n-behaviour(gen_server).\r\n\r\n-export([test_register/0, test_without_register/0, scenarios/0]).\r\n"
},
{
"path": "tests/suites/advanced_tests/src/indexer_example.erl",
"chars": 1180,
"preview": "-module(indexer_example).\n\n-export([indexer_example/0]).\n-export([main/1]).\n-export([indexer12/0, indexer15/0]).\n-export"
},
{
"path": "tests/suites/advanced_tests/src/manolis/good_testcase.txt",
"chars": 583,
"preview": "{9,9,{8,3}}, [{33,{{3,4},x,2}},{32,{{2,0},x,2}},{31,{{4,7},x,2}},{30,{{2,8},y,2}},{29,{{7,5},y,2}},{28,{{0,0},y,2}},{27,"
},
{
"path": "tests/suites/advanced_tests/src/manolis/readme.txt",
"chars": 2695,
"preview": "Οδηγίες εκτέλεσης:\nrush_hour:solve(ML_TESTCASE_IN_A_STRING, LIST_OF_OPTIONS).\nπ.χ.\nTestCase = \"rush_hour 6 6 (5,2) [(0,("
},
{
"path": "tests/suites/advanced_tests/src/manolis/rush_hour.erl",
"chars": 16417,
"preview": "-module(rush_hour).\n\n-export([solve/3, solve/2, print/2, print_path/2, translate/1, toml/2,\n\t test_2workers/0, test_2wor"
},
{
"path": "tests/suites/advanced_tests/src/manolis/search.erl",
"chars": 16045,
"preview": "-module(search).\n\n-export([bfs/4, worker/2]).\n%% CAUTION: worker needs to be exported if it is to be called from the she"
},
{
"path": "tests/suites/advanced_tests/src/manolis/test.erl",
"chars": 341,
"preview": "-module(test).\n\n-export([scenarios/0]).\n-export([test_2workers/0, test_2workers_small/0]).\n\n-concuerror_options_forced(["
},
{
"path": "tests/suites/advanced_tests/src/percept.erl",
"chars": 2221,
"preview": "-module(percept).\n\n-export([scenarios/0]).\n-export([test/0]).\n\n-concuerror_options_forced([{instant_delivery, false}]).\n"
},
{
"path": "tests/suites/advanced_tests/src/preemption.erl",
"chars": 1179,
"preview": "-module(preemption).\n\n-export([preemption/0]).\n-export([scenarios/0]).\n\n-concuerror_options_forced([{instant_delivery, f"
},
{
"path": "tests/suites/advanced_tests/src/receive_deps.erl",
"chars": 935,
"preview": "-module(receive_deps).\n\n-export([test/0]).\n-export([scenarios/0]).\n\n-concuerror_options_forced([{ignore_error, deadlock}"
},
{
"path": "tests/suites/advanced_tests/src/receive_deps_kill.erl",
"chars": 871,
"preview": "-module(receive_deps_kill).\n\n-export([test/0]).\n-export([scenarios/0]).\n\n-concuerror_options_forced(\n [ {ignore_error,"
},
{
"path": "tests/suites/advanced_tests/src/receive_pats.erl",
"chars": 1244,
"preview": "-module(receive_pats).\n\n-export([test1/0, test2/0, test3/0, test4/0]).\n-export([scenarios/0]).\n\n-concuerror_options([{us"
},
{
"path": "tests/suites/advanced_tests/src/receive_patterns.erl",
"chars": 1299,
"preview": "-module(receive_patterns).\n\n-export([test1/0, test2/0]).\n\n-export([scenarios/0]).\n\n-concuerror_options_forced([{use_rece"
},
{
"path": "tests/suites/advanced_tests/src/ring_leader_election.erl",
"chars": 1200,
"preview": "-module(ring_leader_election).\n\n-export([ring_leader_election/0, ring_leader_election/1]).\n-export([scenarios/0]).\n\n-con"
},
{
"path": "tests/suites/advanced_tests/src/ring_leader_election_barrier.erl",
"chars": 1418,
"preview": "-module(ring_leader_election_barrier).\n\n-export([ring_leader_election_barrier/0, ring_leader_election_barrier/1]).\n-expo"
},
{
"path": "tests/suites/advanced_tests/src/ring_leader_election_symmetric.erl",
"chars": 1541,
"preview": "-module(ring_leader_election_symmetric).\n\n-export([ring_leader_election_symmetric/0,\n ring_leader_election_symme"
},
{
"path": "tests/suites/advanced_tests/src/ring_leader_election_symmetric_buffer.erl",
"chars": 3091,
"preview": "-module(ring_leader_election_symmetric_buffer).\n\n-export([ring_leader_election_symmetric_buffer/0,\n ring_leader_"
},
{
"path": "tests/suites/advanced_tests/src/ring_leader_election_symmetric_buffer_2.erl",
"chars": 3103,
"preview": "-module(ring_leader_election_symmetric_buffer_2).\n\n-export([ring_leader_election_symmetric_buffer_2/0,\n ring_lea"
},
{
"path": "tests/suites/advanced_tests/src/send_order.erl",
"chars": 828,
"preview": "-module(send_order).\n-export([test1/0, test2/0]).\n\n%%% See https://github.com/parapluu/Concuerror/issues/77\n\n-export([sc"
},
{
"path": "tests/suites/advanced_tests/src/shared_ptr.erl",
"chars": 1334,
"preview": "%%% Inspired by \"Cartesian Partial-Order Reduction\" paper\n\n-module(shared_ptr).\n\n-export([shared_ptr/0]).\n-export([scena"
},
{
"path": "tests/suites/advanced_tests/src/shootout/pidigits.erl",
"chars": 1155,
"preview": "%% The Great Computer Language Shootout\n%% http://shootout.alioth.debian.org/\n%%\n%% Contributed by : Alkis Gotovos\n%% Cr"
},
{
"path": "tests/suites/advanced_tests/src/shootout/test.erl",
"chars": 139,
"preview": "-module(test).\n\n-export([scenarios/0]).\n-export([test1/0]).\n\nscenarios() ->\n [{test1, inf, dpor}].\n\ntest1() ->\n th"
}
]
// ... and 1082 more files (download for full content)
About this extraction
This page contains the full source code of the parapluu/Concuerror GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1282 files (13.3 MB), approximately 3.6M tokens, and a symbol index with 3 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.