1. the complete title of one (or more) paper(s) published in the open literature describing the work that the author claims describes a human-competitive result; Paper title: "Performance Optimization of Multi-Core Grammatical Evolution Generated Parallel Recursive Programs" ---------------------------------------------------------------------------------------------------------------------------------- 2. the name, complete physical mailing address, e-mail address, and phone number of EACH author of EACH paper(s); Author 1: Gopinath Chennupati Bio-computing and Developmental Systems Group Department of Computer Science and Information Systems University of Limerick, Ireland. Gopinath.Chennupati@ul.ie Author 2: R. Muhammad Atif Azad Bio-computing and Developmental Systems Group Department of Computer Science and Information Systems University of Limerick, Ireland. Atif.Azad@ul.ie Author 3: Conor Ryan Bio-computing and Developmental Systems Group Department of Computer Science and Information Systems University of Limerick, Ireland. Conor.Ryan@ul.ie ---------------------------------------------------------------------------------------------------------------------------------- 3. the name of the corresponding author (i.e., the author to whom notices will be sent concerning the competition); Gopinath Chennupati Gopinath.Chennupati@ul.ie ---------------------------------------------------------------------------------------------------------------------------------- 4. the abstract of the paper(s); Although Evolutionary Computation (EC) has been used with considerable success to evolve computer programs, the majority of this work has targeted the production of serial code. Recent work with Grammatical Evolution (GE) produced Multi-core Grammatical Evolution (MCGE-II), a system that natively produces parallel code, including the ability to execute recursive calls in parallel. This paper extends this work by including practical constraints into the grammars and fitness functions, such as increased control over the level of parallelism for each individual. These changes execute the best-of-generation programs faster than the original MCGE-II with an average factor of $8.13$ across a selection of hard problems from the literature. We analyze the time complexity of these programs and identify avoiding excessive parallelism as a key for further performance scaling. We amend the grammars to evolve a mix of serial and parallel code, which spawns only as many threads as is efficient given the underlying OS and hardware; this speeds up execution by a factor of 9.97. ---------------------------------------------------------------------------------------------------------------------------------- 5. a list containing one or more of the eight letters (A, B, C, D, E, F, G, or H) that correspond to the criteria (see above) that the author claims that the work satisfies; D, E, G ---------------------------------------------------------------------------------------------------------------------------------- 6. a statement stating why the result satisfies the criteria that the contestant claims (see examples of statements of human-competitiveness as a guide to aid in constructing this part of the submission); While the number of processing elements on a single chip increase, it became necessary to exploit the compute power through parallel programming. Automatic systems solve this to some extent in two respects: auto-parallelization and native parallel code generation. Auto-parallelization is hard while native parallel code generation is even harder, the work in this paper falls in the harder category, native parallel code generation. D, E, G: We have shown that using GE, the proposed approach evolves native parallel recursive code on multi-core processors. The state-of-the-art shows almost no attempts in this direction, that in itself shows the difficulty of the set goals in our work. This solution is publishable in its own field as a new scientific result, because a clear solution has been presented to overcome such a complicated problem. The performance of the evolved parallel recursive programs proved competitive with that of the human developed parallel programs on an Intel Xeon E7-4820 processor with 16 cores. The thread creation of human developed parallel recursive programs grow exponentially (2^N). This results in degrading the performance rather than an expected improvement. Fecting an optimal parallelism is the key rather than the excessive parallelization. Finding an ideal controlling mechanism for such a problem is indisputably difficult in its field. We claim that the proposed approach solves this difficulty through the evolution of programs that exhibit optimal parallelism. They showed a significantly better improvement of 17.45% over the human counterparts. Note: In our subsequent research, when the evolved programs are deployed on an Intel processor with a different number of cores, the programs adapt to the hardware architecture. This in itself enables us to evolve architecture independent programs. We also invented a new mechanism that evolves lockfree parallel recursive programs, which exhibited a performance improvement of 25.21% over the human written parallel programs. This research has not been published so far. ---------------------------------------------------------------------------------------------------------------------------------- 7. a full citation of the paper (that is, author names; publication date; name of journal, conference, technical report, thesis, book, or book chapter; name of editors, if applicable, of the journal or edited book; publisher name; publisher city; page numbers, if applicable); 1) Gopinath Chennupati, R. Muhammad Atif Azad, and Conor Ryan, 2015. Performance Optimization of Multi-Core Grammatical Evolution Generated Parallel Recursive Programs: Genetic and Evolutionary Computation Conference (GECCO '15). ACM, DOI=10.1145/2739480.2754746. In press. http://dx.doi.org/10.1145/2739480.2754746 2) Gopinath Chennupati, Muhammad R. Atif Azad, Conor Ryan, 2015 Multi-core GE: Automatic Evolution of Parallel Recursive Programs: in Proceedings of Eighteenth European Conference on Genetic Programming, EuroGP'15, pages 167 -- 178, Copenhagen, Denmark, April 8--10, Springer. 3) Gopinath Chennupati, Jeannie Fitzgerald, Conor Ryan, 2014. On The Efficiency of Multi-core Grammatical Evolution (MCGE) Evolving Multi-Core Parallel Programs: in Proceedings of Sixth World Congress on Nature and Biologically Inspired Computing (NaBIC 2014), pages 238 -- 243, Porto, Portugal, July 30-31, IEEE. 4) Gopinath Chennupati, Muhammad R. Atif Azad, Conor Ryan, 2014. Multi-core GE: Automatic Evolution of CPU Based Multi-core Parallel Programs: in Proceedings of Genetic and Evolutionary Computation Conference Companion, GECCO Comp '14, pages 1041 -- 1044, Vancouver, Canada, July 12-16. ACM ---------------------------------------------------------------------------------------------------------------------------------- 8. a statement either that "any prize money, if any, is to be divided equally among the co-authors" OR a specific percentage breakdown as to how the prize money, if any, is to be divided among the co-authors; Any prize money, if any, is to be divided equally among the co-authors. ---------------------------------------------------------------------------------------------------------------------------------- 9. a statement stating why the authors expect that their entry would be the "best," and The very purpose of GP's invention was for program synthesis. We claim that our work marches forward by fulfilling this purpose with the use of grammars for native parallel code generation. In fact, to some extent, it helps to address the growing concerns of GP's use as a program synthesis tool both in and outside the GP community. We demonstrated the applicability of GE in solving an almost untouched problem both in conventional and evolutionary computing. The work showed a significantly better performance optimization of 17.45% and 25.21% (lockfree programs) over the human written parallel benchmark problems. Our contribution in this direction has been published and/or accepted for publication in a number of recognised international conferences: GECCO '14, EuroGP'15, GECCO'15. More recently, our work on the synthesis of lockfree parallel recursive programs has been accepted for a talk in an eminent conference in the field of parallel computing -- International Conference on Parallel Computing (ParCo '15) Architecture aware parallelization is quite a challenge for many developers, that being the fact, architecture independent parallelization is a daunting task even for the experts. In this research, we observed that the evolving parallel programs adapt effectively to the architecture that they are deployed on (Intel processors with 2, 4, 8 and 16 cores). We claim that it is a great step forward in abstracting out the architecture specific details to the human developer. Overall, a sublime gain of our research is the creation of a rich repository of context free grammars that have the ability to synthesis native parallel code. ---------------------------------------------------------------------------------------------------------------------------------- 10. An indication of the general type of genetic or evolutionary computation used, such as GA (genetic algorithms), GP (genetic programming), ES (evolution strategies), EP (evolutionary programming), LCS (learning classifier systems), GE (grammatical evolution), GEP (gene expression programming), DE (differential evolution), etc. Method Used: Grammatical Evolution (GE) ----------------------------------------------------------------------------------------------------------------------------------