@techreport{CuiSekerinski09ABC,
	address = {Hamilton, Ontario, Canada},
	type = {{SQRL} {Report}},
	title = {An {Experimental} {Implementation} of {Action}-{Based} {Concurrency}},
	url = {https://www.cas.mcmaster.ca/~emil/pubs/CuiSekerinski09ABC.pdf},
	abstract = {This paper reports on an experimental implementation of action-based concurrent objects. Concurrency is expressed by allowing objects to have actions with a guard and a body, in addition to methods and variables. Condition synchronization is expressed by method guards protecting entry into an object. An action of an object can execute any time when its guard is true, with the restriction that at most one action or methods can execute within an object, thus guaranteeing atomicity. In principle, all objects can execute in parallel. The appeal of this model is that it is conceptually simple for programmers and comes with a verification and refinement theory based on atomic actions that is a straightforward extension of that for sequential programs. The concurrency model is suited for tightly coupled shared-memory processors. The implementation makes use of a recent thread library, NPTL, that supports a large number of kernel threads. Each active object has its own thread that cycles through the actions, evaluates their guards, and executes an enabled action. Syntactic constraints restrict when guards need to be re-evaluated. We compare the efficiency of the generated code with that of C/Pthreads, Ada, and Java using classical concurrency examples.},
	number = {58},
	institution = {McMaster University},
	author = {Cui, Xiao-lei and Sekerinski, Emil},
	month = jul,
	year = {2009},
	pages = {25},
}

{"_id":"mmKXbEEAMWd9Tyd6N","bibbaseid":"cui-sekerinski-anexperimentalimplementationofactionbasedconcurrency-2009","author_short":["Cui, X.","Sekerinski, E."],"bibdata":{"bibtype":"techreport","type":"SQRL Report","address":"Hamilton, Ontario, Canada","title":"An Experimental Implementation of Action-Based Concurrency","url":"https://www.cas.mcmaster.ca/~emil/pubs/CuiSekerinski09ABC.pdf","abstract":"This paper reports on an experimental implementation of action-based concurrent objects. Concurrency is expressed by allowing objects to have actions with a guard and a body, in addition to methods and variables. Condition synchronization is expressed by method guards protecting entry into an object. An action of an object can execute any time when its guard is true, with the restriction that at most one action or methods can execute within an object, thus guaranteeing atomicity. In principle, all objects can execute in parallel. The appeal of this model is that it is conceptually simple for programmers and comes with a verification and refinement theory based on atomic actions that is a straightforward extension of that for sequential programs. The concurrency model is suited for tightly coupled shared-memory processors. The implementation makes use of a recent thread library, NPTL, that supports a large number of kernel threads. Each active object has its own thread that cycles through the actions, evaluates their guards, and executes an enabled action. Syntactic constraints restrict when guards need to be re-evaluated. We compare the efficiency of the generated code with that of C/Pthreads, Ada, and Java using classical concurrency examples.","number":"58","institution":"McMaster University","author":[{"propositions":[],"lastnames":["Cui"],"firstnames":["Xiao-lei"],"suffixes":[]},{"propositions":[],"lastnames":["Sekerinski"],"firstnames":["Emil"],"suffixes":[]}],"month":"July","year":"2009","pages":"25","bibtex":"@techreport{CuiSekerinski09ABC,\n\taddress = {Hamilton, Ontario, Canada},\n\ttype = {{SQRL} {Report}},\n\ttitle = {An {Experimental} {Implementation} of {Action}-{Based} {Concurrency}},\n\turl = {https://www.cas.mcmaster.ca/~emil/pubs/CuiSekerinski09ABC.pdf},\n\tabstract = {This paper reports on an experimental implementation of action-based concurrent objects. Concurrency is expressed by allowing objects to have actions with a guard and a body, in addition to methods and variables. Condition synchronization is expressed by method guards protecting entry into an object. An action of an object can execute any time when its guard is true, with the restriction that at most one action or methods can execute within an object, thus guaranteeing atomicity. In principle, all objects can execute in parallel. The appeal of this model is that it is conceptually simple for programmers and comes with a verification and refinement theory based on atomic actions that is a straightforward extension of that for sequential programs. The concurrency model is suited for tightly coupled shared-memory processors. The implementation makes use of a recent thread library, NPTL, that supports a large number of kernel threads. Each active object has its own thread that cycles through the actions, evaluates their guards, and executes an enabled action. Syntactic constraints restrict when guards need to be re-evaluated. We compare the efficiency of the generated code with that of C/Pthreads, Ada, and Java using classical concurrency examples.},\n\tnumber = {58},\n\tinstitution = {McMaster University},\n\tauthor = {Cui, Xiao-lei and Sekerinski, Emil},\n\tmonth = jul,\n\tyear = {2009},\n\tpages = {25},\n}\n\n","author_short":["Cui, X.","Sekerinski, E."],"key":"CuiSekerinski09ABC","id":"CuiSekerinski09ABC","bibbaseid":"cui-sekerinski-anexperimentalimplementationofactionbasedconcurrency-2009","role":"author","urls":{"Paper":"https://www.cas.mcmaster.ca/~emil/pubs/CuiSekerinski09ABC.pdf"},"metadata":{"authorlinks":{}},"downloads":1},"bibtype":"techreport","biburl":"https://api.krunk.cn/emil/bib.php","dataSources":["HEdahWqKBpmSGmDwq","MF5eGzpJnqf6bSAoG","RfxodDQazHHccThPz","ienufKdnmJs49AsjR","So4gmSWFmbQRNEuFs","ezsmw4w22u9JFLNYJ","CvQYP6Tmpapx74Mgr","RWydLHbBJqgdeh5jr"],"keywords":[],"search_terms":["experimental","implementation","action","based","concurrency","cui","sekerinski"],"title":"An Experimental Implementation of Action-Based Concurrency","year":2009,"downloads":1}