{"id":20397303,"url":"https://github.com/tlaplus/concurrentscc","last_synced_at":"2026-05-28T20:31:09.170Z","repository":{"id":137622188,"uuid":"481438381","full_name":"tlaplus/ConcurrentSCC","owner":"tlaplus","description":"Prototypes of Concurrent Strongly Connected Components (SCC) algorithms","archived":false,"fork":false,"pushed_at":"2022-04-14T03:47:28.000Z","size":14194,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"unionfind","last_synced_at":"2026-03-28T13:44:46.224Z","etag":null,"topics":["algorithms","concurrent","scc","tarjan","tlaplus"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/tlaplus.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2022-04-14T02:21:10.000Z","updated_at":"2025-03-29T18:37:18.000Z","dependencies_parsed_at":null,"dependency_job_id":"23e59d43-8787-4683-a185-753d8a9695ac","html_url":"https://github.com/tlaplus/ConcurrentSCC","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/tlaplus/ConcurrentSCC","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tlaplus%2FConcurrentSCC","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tlaplus%2FConcurrentSCC/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tlaplus%2FConcurrentSCC/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tlaplus%2FConcurrentSCC/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/tlaplus","download_url":"https://codeload.github.com/tlaplus/ConcurrentSCC/tar.gz/refs/heads/unionfind","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tlaplus%2FConcurrentSCC/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33626136,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-28T02:00:06.440Z","response_time":99,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algorithms","concurrent","scc","tarjan","tlaplus"],"created_at":"2024-11-15T04:13:13.043Z","updated_at":"2026-05-28T20:31:09.142Z","avatar_url":"https://github.com/tlaplus.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"A Concurrent Strongly Connected Components Algorithm\n====================================================\n\nThis repository contains an implementation of a scalable algorithm to find strongly connected components as proposed in the paper [Multi-core on-the-fly SCC decomposition](https://dl.acm.org/citation.cfm?id=2851161). Core of the implementation is in Java and resides in the package `tarjanUF` which can be found in `src`. This project was done as part of *Google Summer of Code 2018* under the organization *tlaplus*.\n\nThe implementation was ran on several graphs from the BEEM dataset (divine model graphs) with number of threads varying from 1 to 32. The result of the experiment resides in `experiments/plotter/plot_multiple_runs.pdf`. A concurrent union find structure proposed in the paper [A Randomized Concurrent Algorithm for Disjoint Set Union](https://dl.acm.org/citation.cfm?id=2933108) was tried to improve the performance. This results can found in\n`experiments/plotter/plot_path_splitting.pdf` in `tarjanRCUF` branch. Box plots represent the simulations of new structure whereas points represent results of old structure.\n\nTo reproduce the results refer to `experiments/benchmark` script.\n\nA documentation of summary of the algorithm can be found at: `doc/UnionFindConcurrentSCC.pdf`. The algorithm depends on random exploration of graph and takes advantage of already discovered cycles in the graph by other threads to avoid re-exploration. Following example illustrates this:\n\n- Say worker 1 has explored an SCC such that two nodes `A` and `C` are in the same SCC.\n- Consider another worker (say 2) explores `A -\u003e B -\u003e C`.\n- This implies that there is a cycle of the following form: `A -\u003e B -\u003e C -\u003e (some path discovered by worker 1) -\u003e A`.\n\n\nGetting Started\n===============\n\n- Install `oraclejdk` as a dependency.\n- Create a directory: `mkdir bin`\n- To compile the project: `make compile`\n- To run the project: `make run GRAPH=\u003cgraph\u003e THREADS=\u003c#threads\u003e INIT=\u003cinitNodes\u003e`\n- To clean the project: `make clean`\n\nNote that `\u003cgraph\u003e` is provided in an edge list representation. `\u003cinitNodes\u003e` is the list of initial nodes from where DFS will start. This list should ensure that entire graph can be explored. Use `divineParser/augment` to make the nodes contiguous integers (starting from 1) if they are not already.\n\nImplementation\n==============\n\nThe package `tarjanUF` contains several classes which are described as follows:\n\n- GraphNode: A node in a graph whose `arcs` can tell all the outgoing edges of this node. The property `id` identifies this node uniquely. All of the methods of this class are standard.\n- Graph: A graph of `GraphNode`s. It conatins a `HashMap` mapping each node identifier to the node itself. All of the methods of this class are standard.\n- UFNode: This class is an implementation of nodes of an augmented concurrent union-find data structure. Refer to `doc/UnionFindConcurrentSCC.pdf` for an understanding of the data-structure. All properties of this class are atomic/volatile so as to avoid race conditions.\n- UF: This contains methods of manipulating the data structure. It involves standard union find operations along with some cyclic list operations. The latter operations involve merging two lists, remove an element from the list and marking a node dead in the list. The class also contains several auxilary operations to aid in locking of nodes.\n- ConcurrentFastSCC: This is the executor class of the algorithm which initiates the finding of SCCs and returns sets of nodes that belong in the same SCC.\n- SCCWorker: The `run` method of this class implements the iterative version of SCC finding algorithm which is quite similar to the Tarjan's sequential algorithm.\n- ConcurrentBitSet: Used to maintain the set of workers an UFNode is being processed by. A non concurrent bitset would result in race conditions.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftlaplus%2Fconcurrentscc","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftlaplus%2Fconcurrentscc","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftlaplus%2Fconcurrentscc/lists"}