@techreport{SekerinskiZhang14PatternsInLime,
	type = {{CAS} {Technical} {Report}},
	title = {Generic {Parallel} {Patterns} in {Lime}},
	url = {https://www.cas.mcmaster.ca/~emil/pubs/SekerinskiZhang14PatternsInLime.pdf},
	abstract = {Lime is a heterogeneous computing language currently being developed at IBM Research1 [Auerbach et al., 2010]. It is designed to be executable across a broad range of architectures, including CPUs, GPUs, and FPGAs. The novel features of Lime include limiting side-effects and integration of the streaming paradigm into an object- oriented language. Lime extends Java 1.6 as specified by [Gosling et al., 2005]. A design pattern is a reusable solution for a category of problems [Gamma et al., 1995]. Design patterns offer software developers a repertoire of proven solutions that can be tailored for needs. They are highly popular for object-oriented programming and are being used for concurrent and parallel programming. In this document we present a Lime generic implementation of nine parallel design patterns2. The first seven patterns, namely fork-join, parallel generator, map, recurrence, stencil, reduction and scan, are taken from [McCool et al., 2012] except parallel generator (which is a variation of fork-join). The last two patterns, namely “divide and conquer differently” and “divide and conquer”, the latter one being a special case of the former one, are extracted from various applications. We divide the package into three parts: “common”, which defines patterns and operations that are used by other packages; “testcases”, which includes simple examples that can be used for testing the Lime environment; “examples”, which consists of practical problems that can be solved using the generic patterns.},
	institution = {McMaster University},
	author = {Sekerinski, Emil and Zhang, Tian},
	month = nov,
	year = {2014},
	pages = {24},
}

{"_id":"pG392MgMtRafGkM72","bibbaseid":"sekerinski-zhang-genericparallelpatternsinlime-2014","authorIDs":["5d5141906acb07da0100009c","5deb78019e04d1df010000e0","5df0c9af96fa76de0100004a","5df1e05078da84de01000007","5e0152666afa18de01000079","5e14924f08c265de01000191","5e159bdce8bfcff201000064","5e1c7d5192587bde010001a6","5e1e0b00f6dca7f201000020","5e2827e2e6485dde01000035","5e288b4067e11edf01000130","5e2f394178a7cedf010000dc","5e34df5862bc74de010000f4","5e3c065bea028bde0100018f","5e4f908242a908de010000e9","5e585f852c2732de010001b4","5e5948def5822adf01000075","5e5d99be5726ecdf010000d1","5e600cdf13e3aede010001f5","5e69048f8457bade010002a1","5e6acf2ad15181f301000141","92uEQKMDcvvBMsZhM","Ge6aoqtpksMCtyrhL","YfeH5nK5eMWgp3gGy","anKewCA9AWgtndQzB","cwnpJhAGnLcWDSWqt","dochF8eFSd3jy8jcD","e6xvbhubvq5PtsszN","mixtvxbFoDFYKhAQq","oAZuP8sa3gmYvdqKk","qz4iM7vyMs82Hvx8j","wsgyLi66Pkv72928T","xset8hhxmqR8QvHh5"],"author_short":["Sekerinski, E.","Zhang, T."],"bibdata":{"bibtype":"techreport","type":"CAS Technical Report","title":"Generic Parallel Patterns in Lime","url":"https://www.cas.mcmaster.ca/~emil/pubs/SekerinskiZhang14PatternsInLime.pdf","abstract":"Lime is a heterogeneous computing language currently being developed at IBM Research1 [Auerbach et al., 2010]. It is designed to be executable across a broad range of architectures, including CPUs, GPUs, and FPGAs. The novel features of Lime include limiting side-effects and integration of the streaming paradigm into an object- oriented language. Lime extends Java 1.6 as specified by [Gosling et al., 2005]. A design pattern is a reusable solution for a category of problems [Gamma et al., 1995]. Design patterns offer software developers a repertoire of proven solutions that can be tailored for needs. They are highly popular for object-oriented programming and are being used for concurrent and parallel programming. In this document we present a Lime generic implementation of nine parallel design patterns2. The first seven patterns, namely fork-join, parallel generator, map, recurrence, stencil, reduction and scan, are taken from [McCool et al., 2012] except parallel generator (which is a variation of fork-join). The last two patterns, namely “divide and conquer differently” and “divide and conquer”, the latter one being a special case of the former one, are extracted from various applications. We divide the package into three parts: “common”, which defines patterns and operations that are used by other packages; “testcases”, which includes simple examples that can be used for testing the Lime environment; “examples”, which consists of practical problems that can be solved using the generic patterns.","institution":"McMaster University","author":[{"propositions":[],"lastnames":["Sekerinski"],"firstnames":["Emil"],"suffixes":[]},{"propositions":[],"lastnames":["Zhang"],"firstnames":["Tian"],"suffixes":[]}],"month":"November","year":"2014","pages":"24","bibtex":"@techreport{SekerinskiZhang14PatternsInLime,\n\ttype = {{CAS} {Technical} {Report}},\n\ttitle = {Generic {Parallel} {Patterns} in {Lime}},\n\turl = {https://www.cas.mcmaster.ca/~emil/pubs/SekerinskiZhang14PatternsInLime.pdf},\n\tabstract = {Lime is a heterogeneous computing language currently being developed at IBM Research1 [Auerbach et al., 2010]. It is designed to be executable across a broad range of architectures, including CPUs, GPUs, and FPGAs. The novel features of Lime include limiting side-effects and integration of the streaming paradigm into an object- oriented language. Lime extends Java 1.6 as specified by [Gosling et al., 2005]. A design pattern is a reusable solution for a category of problems [Gamma et al., 1995]. Design patterns offer software developers a repertoire of proven solutions that can be tailored for needs. They are highly popular for object-oriented programming and are being used for concurrent and parallel programming. In this document we present a Lime generic implementation of nine parallel design patterns2. The first seven patterns, namely fork-join, parallel generator, map, recurrence, stencil, reduction and scan, are taken from [McCool et al., 2012] except parallel generator (which is a variation of fork-join). The last two patterns, namely “divide and conquer differently” and “divide and conquer”, the latter one being a special case of the former one, are extracted from various applications. We divide the package into three parts: “common”, which defines patterns and operations that are used by other packages; “testcases”, which includes simple examples that can be used for testing the Lime environment; “examples”, which consists of practical problems that can be solved using the generic patterns.},\n\tinstitution = {McMaster University},\n\tauthor = {Sekerinski, Emil and Zhang, Tian},\n\tmonth = nov,\n\tyear = {2014},\n\tpages = {24},\n}\n\n","author_short":["Sekerinski, E.","Zhang, T."],"key":"SekerinskiZhang14PatternsInLime","id":"SekerinskiZhang14PatternsInLime","bibbaseid":"sekerinski-zhang-genericparallelpatternsinlime-2014","role":"author","urls":{"Paper":"https://www.cas.mcmaster.ca/~emil/pubs/SekerinskiZhang14PatternsInLime.pdf"},"metadata":{"authorlinks":{"sekerinski, e":"https://bibbase.org/show?bib=https%3A%2F%2Fapi.krunk.cn%2Femil%2Fbib.php"}},"downloads":3},"bibtype":"techreport","biburl":"https://api.krunk.cn/emil/bib.php","creationDate":"2019-08-15T00:44:32.443Z","downloads":3,"keywords":[],"search_terms":["generic","parallel","patterns","lime","sekerinski","zhang"],"title":"Generic Parallel Patterns in Lime","year":2014,"dataSources":["HEdahWqKBpmSGmDwq","rRazdBuE63ZLofRun","MF5eGzpJnqf6bSAoG","ienufKdnmJs49AsjR","So4gmSWFmbQRNEuFs","ezsmw4w22u9JFLNYJ","CvQYP6Tmpapx74Mgr","RWydLHbBJqgdeh5jr"]}