Referências

Abellard, P., G. Nolibe, and N. Razafindrakoto. 1990. “A Data Flow Architecture for Parallel Computation.” Databases, Parallel Architectures and Their Applications,. PARBASE-90, International Conference on, March, 129–31. https://doi.org/10.1109/PARBSE.1990.77130.

Ackerman, W. B. 1982. “Data Flow Languages.” Computer 15 (2): 15–25. https://doi.org/10.1109/MC.1982.1653938.

Adriaens, Jacob T., Katherine Compton, Nam Sung Kim, and Michael J. Schulte. 2012. “The Case for GPGPU Spatial Multitasking.” IEEE International Symposium on High-Performance Comp Architecture, February, 1–12. https://doi.org/10.1109/HPCA.2012.6168946.

Adve, Vikram, Chris Lattner, Michael Brukman, Anand Shukla, and Brian Gaeke. 2003a. “LLVA: A Low-Level Virtual Instruction Set Architecture.” 22nd Digital Avionics Systems Conference. Proceedings (Cat. No.03CH37449) (San Diego, California), December, 205–16. https://doi.org/10.1109/MICRO.2003.1253196.

Adve, Vikram, Chris Lattner, Michael Brukman, Anand Shukla, and Brian Gaeke. 2003b. “LLVA: A Low-level Virtual Instruction Set Architecture.” Proceedings of the 36th annual ACM/IEEE international symposium on Microarchitecture (MICRO-36) (San Diego, California), December.

Alegre, Porto. 2011. hiCUDA e OpenMPC.

Aleksandar Ilic, Frederico Pratas, and Leonel Sousa. 2015. “CARM: Cache-Aware Performance, Power and Energy-Efficiency Roofline Modeling.” Compiler, Architecture and Tools Conference (Intel Haifa, Israel), CATC’15.

Alexandru, Alexander, and Aiken Nicolau. 1988. Optimal Loop Parallelization*. 308–17.

Allen, Randy, Language Design, and Ken Kennedy. 1999. Automatic Loop Interchange. 75–90.

Al-Mouhamed, M., and A. ul Hassan Khan. 2012. “Exploration of Automatic Optimization for CUDA Programming.” Parallel Distributed and Grid Computing (PDGC), 2012 2nd IEEE International Conference on, December, 55–60. https://doi.org/10.1109/PDGC.2012.6449791.

AMD. 2013a. AMD Heterogeneous Computing Site. http://developer.amd.com/tools-and-sdks/heterogeneous-computing/.

AMD. 2013b. “AMD Heterogeneous Computing Site @ONLINE.” http://developer.amd.com/tools-and-sdks/heterogeneous-computing/.

Amdahl, Gene M. 1967. “Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities.” Proceedings of the April 18-20, 1967, Spring Joint Computer Conference on - AFIPS ’67 (Spring) (New York, New York, USA), April, 483. https://doi.org/10.1145/1465482.1465560.

Amini, Mehdi, Corinne Ancourt, Fabien Coelho, et al. 2011. “PIPS Is Not (Just) Polyhedral Software.” International Workshop on Polyhedral Compilation Techniques (IMPACT’11), Chamonix, France.

Amini, Mehdi, Fabien Coelho, Serge Guelton, et al. 2011. PIPS: Internal Representation of Fortran and c Code. 1–33.

Amini, Mehdi, Béatrice Creusillet, Stéphanie Even, et al. 2012. “Par4All: From Convex Array Regions to Heterogeneous Computing.” 2nd International Workshop on Polyhedral Compilation Techniques, Impact (Jan 2012).

Amini, Mehdi, Amaury Darsch, Onil Goubier, et al. 2012. Par4All Developer Guide — HPC Project.

Amini, Mehdi, Onil Goubier, Serge Guelton, Ronan Keryell, and Janice Onanian-mcmahon. 2012. Par4All User Guide P4a — HPC Project. 1–14.

Amini, Mehdi, and Ronan Keryell. 2012. SoSlang: SOurce-to-Source Clang.

Analysis, Locality. n.d. • a Dependence d = ( d 1 , . . . , d.

Analysis, Program. 2011. LLVM to PTX Backend. 1–15.

Ancourt, Corinne, Fabien Coelho, and Guillaume Oget. 2010. Tpips: Command Line Interpreter. 2010 (revision 15925).

Ancourt, Corinne, Ronan Keryell, and Mines Paristech. 2012. Par4All & PIPS Programming Rules. 1–7.

Angeles, Los. 2012. Polyhedral Optimizations for Low-Level Compilers. 1–46.

Antão, Diogo, Luı́s Taniça, Aleksandar Ilic, Frederico Pratas, Pedro Tomás, and Leonel Sousa. 2014. “Monitoring Performance and Power for Application Characterization with the Cache-Aware Roofline Model.” In Parallel Processing and Applied Mathematics SE - 70, edited by Roman Wyrzykowski, Jack Dongarra, Konrad Karczewski, and Jerzy Waśniewski, vol. 8384. Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-55224-3{\_}70.

Anvik, J., S. MacDonald, D. Szafron, J. Schaeffer, and S. Bromling. n.d. “Generating Parallel Programs from the Wavefront Design Pattern.” Proceedings 16th International Parallel and Distributed Processing Symposium, 104. https://doi.org/10.1109/IPDPS.2002.1016487.

Aparapi. 2011. “Aparapi. API for Data Parallel Java.” https://code.google.com/p/aparapi/.

Arandi, Samer, and Paraskevas Evripidou. 2010. Programming Multi-Core Architectures Using Data-Flow Techniques 1.

Architecture, Openmp, and Review Board. 2011. OpenMP Application Program Interface. no. July.

Argollo, Eduardo, and Martin Griebl. n.d. Loop Parallelization for a Grid Master- Worker Framework ∗. no. 004265.

Arora, Nipun. n.d. COMPASS: Community Driven Parallelization Advisor for Legacy Software Systems.

Arts, T H E, Child Policy, Civil Justice, National Security, Public Safety, and Homeland Security. n.d. Support RAND.

Asanovic, Krste, Ras Bodik, Bryan Christopher Catanzaro, et al. 2006. The Landscape of Parallel Computing Research: A View from Berkeley. UCB/EECS-2006-183. EECS Department, University of California, Berkeley. http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-183.html.

Asanovic, Krste, Rastislav Bodik, James Demmel, et al. 2009. “A View of the Parallel Computing Landscape.” Communications of the ACM (New York, NY, USA) 52 (10): 56–67. https://doi.org/10.1145/1562764.1562783.

Aug, Adam Simpson. 2011. C Ompute u Nified d Evice a Rchitecture.

Augonnet, Cédric, Samuel Thibault, and Raymond Namyst. 2010. StarPU: a Runtime System for Scheduling Tasks over Accelerator-Based Multicore Machines. Research Report RR-7240. INRIA. https://hal.inria.fr/inria-00467677.

Aumage, Olivier, Nathalie Furmento, Raymond Namyst, and Samuel Thibault. 2012. StarPU-MPI: Task Programming over Clusters of Machines Enhanced with Accelerators. 7490 (EuroMPI): 1–2.

Avresky, Dimiter R., and David R. Kaeli. 1998. Fault-Tolerant Parallel and Distributed Systems. Springer US. https://doi.org/10.1007/978-1-4615-5449-3.

Ayguade, E, N Copty, A Duran, et al. 2009. “The Design of OpenMP Tasks.” Parallel and Distributed Systems, IEEE Transactions on 20 (3): 404–18. https://doi.org/10.1109/TPDS.2008.105.

Azimi, Reza, Michael Stumm, and Robert W. Wisniewski. 2005. “Online Performance Analysis by Statistical Sampling of Microprocessor Performance Counters.” Proceedings of the 19th Annual International Conference on Supercomputing - ICS ’05 (New York, New York, USA), June, 101. https://doi.org/10.1145/1088149.1088163.

Bacon, David F., Susan L. Graham, Oliver, and J. Sharp. 1994. “Compiler Transformations for High-Performance Computing.” ACM Computing Surveys 26: 345–420.

Bacon, David F., Susan L. Graham, and Oliver J. Sharp. 1993. Compiler Transformations for High-Performance Computing. UCB/CSD-93-781. EECS Department, University of California, Berkeley. http://www.eecs.berkeley.edu/Pubs/TechRpts/1993/6309.html.

Bacon, David F., Susan L. Graham, and Oliver J. Sharp. 1994. “Compiler Transformations for High-Performance Computing.” ACM Comput. Surv. (New York, NY, USA) 26: 345–420. https://doi.org/http://doi.acm.org/10.1145/197405.197406.

Bacon, David, Rodric Rabbah, and Sunil Shukla. 2013. “FPGA Programming for the Masses.” Queue (New York, NY, USA) 11 (2): 40:40–52. https://doi.org/10.1145/2436696.2443836.

Badia, Rosa M, Francisco D Igual, and Rafael Mayo. n.d. An Extension of the StarSs Programming Model for Platforms with Multiple GPUs.

Baghdadi, Soufiane, and Albert Cohen. n.d. Putting Automatic Polyhedral Compilation for GPGPU to Work.

Baines, Paul. n.d. Journal of Statistical Software. VV (Ii).

Bala, Vasanth, Evelyn Duesterwald, and Sanjeev Banerjia. n.d. Dynamo: A Transparent Dynamic Optimization System. 1–12.

Balfour, James. 2011. CUDA Threads and Atomics. no. April.

Basaran, Can, and Kyoung-Don Kang. 2012. “Supporting Preemptive Task Executions and Memory Copies in GPGPUs.” 2012 24th Euromicro Conference on Real-Time Systems, July, 287–96. https://doi.org/10.1109/ECRTS.2012.15.

Baskaran, Muthu Manikandan, J. Ramanujam, and P. Sadayappan. 2010a. “Automatic c-to-CUDA Code Generation for Affine Programs.” Proceedings of the 19th Joint European Conference on Theory and Practice of Software, International Conference on Compiler Construction (Berlin, Heidelberg), CC’10/ETAPS’10, 244–63. https://doi.org/10.1007/978-3-642-11970-5_14.

Baskaran, Muthu Manikandan, J Ramanujam, and P Sadayappan. 2010b. LNCS 6011 - Automatic c-to-CUDA Code Generation for Affine Programs. 244–63.

Bastoul, Cédric. 2004a. “Code Generation in the Polyhedral Model Is Easier Than You Think.” 29 september - 3 october 2004, antibes juan-les-pins, france, 7–16.

Bastoul, Cédric. 2004c. “Code Generation in the Polyhedral Model Is Easier Than You Think.” PACT’13 IEEE International Conference on Parallel Architecture and Compilation Techniques (Juan-les-Pins, France), 7–16.

Bastoul, Cédric. 2004b. “Code Generation in the Polyhedral Model Is Easier Than You Think.” PACT’13 IEEE International Conference on Parallel Architecture and Compilation Techniques (Juan-les-Pins, France), 7–16.

Bastoul, Cédric. 2004d. “Code Generation in the Polyhedral Model Is Easier Than You Think.” Proceedings of the 13th International Conference on Parallel Architectures and Compilation Techniques (Washington, DC, USA), PACT ’04, 7–16. https://doi.org/10.1109/PACT.2004.11.

Bastoul, Cédric. 2011c. OpenScop: A Specification and a Library for Data Exchange in Polyhedral Compilation Tools. Paris-Sud University, France.

Bastoul, Cédric. 2011b. OpenScop: A Specification and a Library for Data Exchange in Polyhedral Compilation Tools. Paris-Sud University, France.

Bastoul, Cédric. 2011a. OpenScop: A Specification and a Library for Data Exchange in Polyhedral Compilation Tools. Paris-Sud University, France.

Bastoul, Cedric, Albert Cohen, Sylvain Girbal, Saurabh Sharma, and Olivier Temam. 2008. Clan a Polyhedral Representation Extractor for High Level Programs Edition 1.0, for Clan 1.0.0.

Bastoul, Cédric, Albert Cohen, Sylvain Girbal, Saurabh Sharma, and Olivier Temam. 2003b. “Putting Polyhedral Loop Transformations to Work.” LCPC’16 International Workshop on Languages and Compilers for Parallel Computers, LNCS 2958 (College Station, Texas), 209–25.

Bastoul, Cédric, Albert Cohen, Sylvain Girbal, Saurabh Sharma, and Olivier Temam. 2003a. “Putting Polyhedral Loop Transformations to Work.” LCPC’16 International Workshop on Languages and Compilers for Parallel Computers, LNCS 2958 (College Station, Texas), 209–25.

Basupalli, V, T Yuki, S Rajopadhye, et al. 2011. “ompVerify: Polyhedral Analysis for the OpenMP Programmer.” In OpenMP in the Petascale Era, edited by BarbaraM. Chapman, WilliamD. Gropp, Kalyan Kumaran, and MatthiasS. Müller, vol. 6665. Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-21487-5{\_}4.

Bataev, Alexey, Andrey Bokhanko, and James Cownie. n.d. Towards OpenMP Support in LLVM. 1–23.

Bauer, Michael, Henry Cook, and Brucek Khailany. n.d. CudaDMA: Optimizing GPU Memory Bandwidth via Warp ∗ Specialization.

Bauer, Sebastian, Sebastian Kohler, Konrad Doll, and Ulrich Brunsmann. 2010. “FPGA-GPU Architecture for Kernel SVM Pedestrian Detection.” 2010 IEEE Computer Society Conference on Computer Vision and Pattern Recognition - Workshops, June, 61–68. https://doi.org/10.1109/CVPRW.2010.5543772.

Becchi, Michela, Surendra Byna, Srihari Cadambi, and Srimat Chakradhar. 2010. “Data-Aware Scheduling of Legacy Kernels on Heterogeneous Platforms with Distributed Memory.” Proceedings of the 22nd ACM Symposium on Parallelism in Algorithms and Architectures - SPAA ’10 (New York, New York, USA), June, 82. https://doi.org/10.1145/1810479.1810498.

Begeman, Nate. 2008. Building an Efficient JIT.

Bell, Nathan, and Jared Hoberock. 2012. Thrust: A Productivity-Oriented Library for CUDA 26. 359–72.

Bellard, Fabrice. 2005. “QEMU, a Fast and Portable Dynamic Translator.” Proceedings of the Annual Conference on USENIX Annual Technical Conference (Berkeley, CA, USA), ATEC ’05, 41–41. http://dl.acm.org/citation.cfm?id=1247360.1247401.

Benabderrahmane, Mohamed-walid, and Albert Cohen. n.d. A Conservative Approach to Handle Full Functions in the Polyhedral Model. no. 6814.

Benabderrahmane, Mohamed-Walid, Louis-Noël Pouchet, Albert Cohen, and Cédric Bastoul. 2010. “The Polyhedral Model Is More Widely Applicable Than You Think.” Proceedings of the 19th Joint European Conference on Theory and Practice of Software, International Conference on Compiler Construction (Berlin, Heidelberg), CC’10/ETAPS’10, 283–303. https://doi.org/10.1007/978-3-642-11970-5_16.

Ben-Ari, M. 1990. Principles of Concurrent and Distributed Programming. Prentice-Hall, Inc.

Ben-Ari, Mordechai, and Yifat Ben-David Kolikant. 1999. “Thinking Parallel: The Process of Learning Concurrency.” ACM SIGCSE Bulletin 31: 13–16.

Berlin, Daniel, David Edelsohn, and Sebastian Pop. n.d. High-Level Loop Optimizations for GCC.

Bernstein, A J. 1966. Analysis Programs Processing. 8 (5): 306–7.

Bertolli, C., S. F. F Antao, A. E. E Eichenberger, et al. 2014. “Coordinating GPU Threads for OpenMP 4.0 in LLVM.” LLVM Compiler Infrastructure in HPC (LLVM-HPC), 2014, November, 12–21. https://doi.org/10.1109/LLVM-HPC.2014.10.

Bertolli, C., S. F. Antao, A. E. Eichenberger, et al. 2014. LLVM Compiler Infrastructure in HPC (LLVM-HPC), 2014. https://doi.org/10.1109/LLVM-HPC.2014.10.

Bienia, Christian, Sanjeev Kumar, Jaswinder Pal Singh, and Kai Li. n.d. The PARSEC Benchmark Suite: Characterization and Architectural Implications.

Bondhugula, Uday. 2012. “PLUTO - an Automatic Parallelizer and Locality Optimizer for Multicores @ONLINE.” http://pluto-compiler.sourceforge.net/.

Bondhugula, Uday, Albert Cohen, J. Ramanujam, P. Sadayappan, Louis-Noel Pouchet, and Cedric Bastoul. 2010. “Combined Iterative and Model-Driven Optimization in an Automatic Parallelization Framework.” 2010 ACM/IEEE International Conference for High Performance Computing, Networking, Storage and Analysis, no. November (November): 1–11. https://doi.org/10.1109/SC.2010.14.

Bondhugula, Uday, Albert Cohen, J Ramanujam, P Sadayappan, and Nicolas Vasilache. 2011. Loop Transformations: Convexity, Pruning and Optimization.

Bondhugula, Uday, Albert Hartono, J. Ramanujam, and P. Sadayappan. 2008b. “A Practical Automatic Polyhedral Parallelizer and Locality Optimizer.” Proceedings of the 2008 ACM SIGPLAN Conference on Programming Language Design and Implementation (New York, NY, USA), PLDI ’08, 101–13. https://doi.org/10.1145/1375581.1375595.

Bondhugula, Uday, Albert Hartono, J. Ramanujam, and P. Sadayappan. 2008a. “A Practical Automatic Polyhedral Parallelizer and Locality Optimizer.” Proceedings of the 2008 ACM SIGPLAN Conference on Programming Language Design and Implementation (New York, NY, USA), PLDI ’08, 101–13. https://doi.org/10.1145/1375581.1375595.

Bondhugula, Uday, Albert Hartono, J. Ramanujam, and P. Sadayappan. 2008c. “A Practical Automatic Polyhedral Parallelizer and Locality Optimizer.” SIGPLAN Not. (New York, NY, USA) 43 (6): 101–13. https://doi.org/10.1145/1379022.1375595.

Bondhugula, Uday, Albert Hartono, J. Ramanujam, and P. Sadayappan. 2008d. “A Practical Automatic Polyhedral Program Optimization System.” ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), June.

Bondhugula, Uday, J. Ramanujam, and et al. 2008. “PLuTo: A Practical and Fully Automatic Polyhedral Program Optimization System.” IN: PROCEEDINGS OF THE ACM SIGPLAN 2008 CONFERENCE ON PROGRAMMING LANGUAGE DESIGN AND IMPLEMENTATION (PLDI 08.

Bondhugula, Uday, J. Ramanujam, and P. Sadayappan. 2007. PLuTo: A Practical and Fully Automatic Polyhedral Parallelizer and Locality Optimizer. OSU-CISRC-10/07-TR70. The Ohio State University.

Borin, Edson, Youfeng Wu, Cheng Wang, et al. n.d. TAO: Two-Level Atomicity for Dynamic Binary Optimizations. 12–21.

Brodtkorb, A. R., C. Dyken, T. R. Hagen, J. M. Hjelmervik, and O. O. Storaasli. 2010. “State-of-the-Art in Heterogeneous Computing.” Scientific Programming 18 (1): 1–33.

Buck, I. 2007. “GPU Computing: Programming a Massively Parallel Processor.” International Symposium on Code Generation and Optimization (CGO’07), 17–17. https://doi.org/10.1109/CGO.2007.13.

Buck, Ian. n.d. Data Parallel Computing on Graphics Hardware.

Buck, Ian, Tim Foley, Daniel Horn, et al. 2004a. “Brook for GPUs: Stream Computing on Graphics Hardware.” ACM SIGGRAPH 2004 Papers (New York, NY, USA), SIGGRAPH ’04, 777–86. https://doi.org/10.1145/1186562.1015800.

Buck, Ian, Tim Foley, Daniel Horn, et al. 2004b. “Brook for GPUs: Stream Computing on Graphics Hardware.” ACM Trans. Graph. (New York, NY, USA) 23 (3): 777–86. https://doi.org/10.1145/1015706.1015800.

Buck, Ian, Tim Foley, Daniel Horn, et al. 2004c. “Brook for GPUs: Stream Computing on Graphics Hardware.” ACM TRANSACTIONS ON GRAPHICS 23: 777–86.

CAMUS. 2015. “Apollo: Automatic speculative POLyhedral Loop Optimizer.” https://team.inria.fr/camus/apollo/.

Caparrós Cabezas, Victoria, and Markus Püschel. 2014. “Extending the Roofline Model: Bottleneck Analysis with Microarchitectural Constraints.” 2014 IEEE International Symposium on Workload Characterization (IISWC), October, 222–31. https://doi.org/10.1109/IISWC.2014.6983061.

Cavazos, John, Scott Grauer-Gray, Robert Searles, William Killian, Lifan Xu, and Sudhee Ayalasomayajula. 2012. PolyBench/ACC The Polyhedral Benchmark Suite Targeting Multicore CPUs, GPUs, and Accelerators. http://cavazos-lab.github.io/PolyBench-ACC/.

Chapman, Barbara, Gabriele Jost, and Ruud van der Pas. 2007. Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation). The MIT Press.

Cheung, Shun Yan. 2013. “Introduction to Parallel Processing. OpenMP.” http://www.mathcs.emory.edu/{~}cheung/Courses/355/Syllabus/91-pthreads/openMP.html.

Clang, Site. 2013. “Clang Site @ONLINE.” http://clang.llvm.org/.

COULOMB, Kevin, Augustin DEGOMME, Mathieu Faverge, and François TRAHAY. 2011. “An open source tool chain for performance analysis.” 5th Parallel Tools Workshop (Dresden, Germany), September. https://hal.archives-ouvertes.fr/hal-00707236.

Creusillet, Béatrice, and François Irigoin. 1996. “Interprocedural Array Region Analyses.” Languages and Compilers for Parallel Computing, 46–60.

“cuBLAS-XT ? Accelerate BLAS Calls with Multiple GPUs!” 2014. http://developer.nvidia.com/cublasxt.

Cytron, R., J. Ferrante, B. K. Rosen, M. N. Wegman, and F. K. Zadeck. 1989. “An Efficient Method of Computing Static Single Assignment Form.” Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (New York, NY, USA), POPL ’89, 25–35. https://doi.org/10.1145/75277.75280.

Dagum, Leonardo, and Ramesh Menon. 1998. “OpenMP: An Industry-Standard API for Shared-Memory Programming.” IEEE Computational Science and Engineering 5 (1): 46–55. https://doi.org/10.1109/99.660313.

Dave, C., Hansang Bae, Seung-Jai Min, Seyong Lee, R. Eigenmann, and S. Midkiff. 2009. “Cetus: A Source-to-Source Compiler Infrastructure for Multicores.” Computer 42 (12): 36–42. https://doi.org/10.1109/MC.2009.385.

Dave, Chirag, Hansang Bae, Seung-jai Min, et al. 2009. “Cetus: A Source-to-Source Compiler Infrastructure for Multicores.” Computer 42 (12): 36–42. https://doi.org/10.1109/MC.2009.385.

Dean, Jeffrey, and Sanjay Ghemawat. 2004. “MapReduce: Simplified Data Processing on Large Clusters.” Proceedings of the 6th Conference on Symposium on Opearting Systems Design & Implementation - Volume 6 (Berkeley, CA, USA), OSDI’04, 10–10. http://dl.acm.org/citation.cfm?id=1251254.1251264.

Dean, Jeffrey, and Sanjay Ghemawat. 2008. “MapReduce: Simplified Data Processing on Large Clusters.” Commun. ACM (New York, NY, USA) 51 (1): 107–13. https://doi.org/10.1145/1327452.1327492.

Delistavrou, C T, and K G Margaritis. 2011. “Towards an Integrated Teaching Environment for Parallel Programming.” Informatics (PCI), 2011 15th Panhellenic Conference on, 3–7. https://doi.org/10.1109/PCI.2011.16.

Dollinger, Jean-François, and Vincent Loechner. 2015. “CPU+GPU Load Balance Guided by Execution Time Prediction.” Fifth International Workshop on Polyhedral Compilation Techniques (IMPACT 2015) (Amsterdam, Netherlands), January. https://hal.inria.fr/hal-01095890.

Dongarra, Jack J, Hans W Meuer, and Erich Strohmaier. 1994. TOP500 Supercomputer Sites. RUM 37/94, University of Mannheim, June 30, 1994; University of Mannheim. www.netlib.org/benchmark/top500/lists/rum3894.ps.

Dongarra, Jack J, Hans W Meuer, and Erich Strohmaier. 1996. TOP500 Supercomputer Sites. RUM 48/96, University of Mannheim, November 18, 1996; University of Mannheim. http://www.netlib.org/utk/people/JackDongarra/pdf/top500_9611.pdf.

Dongarra, Jack J, Hans W Meuer, Erich Strohmaier, et al. 1997. “TOP500 Supercomputer Sites.” Supercomputer 13: 89–111.

DragonEgg. 2013. “DragonEgg - Using LLVM as a GCC Backend.” http://dragonegg.llvm.org/.

Du, Peng, Rick Weber, Piotr Luszczek, Stanimire Tomov, Gregory Peterson, and Jack Dongarra. 2012a. “From {CUDA} to OpenCL: Towards a Performance-Portable Solution for Multi-Platform {GPU} Programming.” Parallel Computing 38 (8): 391–407. https://doi.org/http://dx.doi.org/10.1016/j.parco.2011.10.002.

Du, Peng, Rick Weber, Piotr Luszczek, Stanimire Tomov, Gregory Peterson, and Jack Dongarra. 2012b. “From CUDA to OpenCL: Towards a Performance-portable Solution for Multi-platform GPU Programming.” Parallel Computing (Amsterdam, The Netherlands, The Netherlands) 38 (8): 391–407. https://doi.org/10.1016/j.parco.2011.10.002.

Eichenberger, Alexandre E., John Mellor-Crummey, Martin Schulz, et al. 2013. OpenMP in the Era of Low Power Devices and Accelerators. Edited by Alistair P. Rendell, Barbara M. Chapman, and Matthias S. Müller. Vol. 8122. Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-40698-0.

Entreprise, CAPS. 2012. “OpenHMPP Directives.” November. http://www.caps-entreprise.com/openhmpp-directives/.

Faber, Peter. 2007. Code Optimization in the Polyhedron Model – Improving the Efficiency of Parallel Loop Nests.

Faber, Peter, Martin Griebl, and Christian Lengauer. 2001. Loop-Carried Code Placement. 230–35.

Faber, Peter, Martin Griebl, and Christian Lengauer. 2003. Replicated Placements in the Polyhedron Model. 303–8.

Faber, Peter, Martin Griebl, and Christian Lengauer. n.d. Issues of the Automatic Generation of HPF Loop Programs.

Falcao, G. 2013. “How Fast Can Parallel Programming Be Taught to Undergraduate Students?” Potentials, IEEE 32 (4): 28–29. https://doi.org/10.1109/MPOT.2012.2234507.

Fastest, The. n.d. Kepler GK110.

Feautrier, Paul. 1996. “Automatic Parallelization in the Polytope Model.” Laboratoire PRiSM, Universit� Des Versailles St-Quentin En Yvelines, 45, Avenue Des �Tats-Unis, f-78035 Versailles Cedex, 79–103. http://link.springer.com/chapter/10.1007/3-540-61736-1{\_}44.

Feautrier, Paul. 2009. The Polytope Model: Past, Present, Future.

Feiner, Peter, Angela Demke Brown, and Ashvin Goel. 2012. “Comprehensive Kernel Instrumentation via Dynamic Binary Translation.” Proceedings of the Seventeenth International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS ’12 (New York, New York, USA), 135. https://doi.org/10.1145/2150976.2150992.

Ferner, C, B Wilkinson, and B Heath. 2013. “Toward Using Higher-Level Abstractions to Teach Parallel Computing.” Parallel and Distributed Processing Symposium Workshops PhD Forum (IPDPSW), 2013 IEEE 27th International, 1291–96. https://doi.org/10.1109/IPDPSW.2013.71.

Fifield, Jeff. 2011. SKIR: Just-in-Time Compilation for Parallelism with LLVM.

Flynn, Michael J. n.d. Using FPGAs for HPC* Acceleration: Now and in 20 Years.

For, Techniques, and Scalable Performance. 2012. C Ov Er f e at u Re. 26–32.

Fpgas, Xilinx, and High Performance Computing. 2010. Xilinx WP375 High Performance Computing Using FPGAs, White Paper. 375: 1–15.

Frost, Gary, and Andrew Sheppard. 2012. Aparapi ~ the Easy Way to Program Java+GPU.

Fujita, Syoyo. n.d. Adding LLVM JIT Facility to Your Program.

Gad, Ramy, Tim Suss, and Andre Brinkmann. 2014. “Compiler Driven Automatic Kernel Context Migration for Heterogeneous Computing.” 2014 IEEE 34th International Conference on Distributed Computing Systems, June, 389–98. https://doi.org/10.1109/ICDCS.2014.47.

Gautier, Thierry, Joao V. F. Lima, Nicolas Maillard, Bruno Raffin, and Distributed Processing. 2013. “XKaapi: A Runtime System for Data-Flow Task Programming on Heterogeneous Architectures.” 2013 IEEE 27th International Symposium on Parallel and Distributed Processing, May, 1299–308. https://doi.org/10.1109/IPDPS.2013.66.

GCC. 2012. “Manual Do GCC: The c Preprocessor @ONLINE.” http://gcc.gnu.org/onlinedocs/cpp/index.html.

GCC. 2015. GCC, the GNU Compiler Collection. https://gcc.gnu.org/.

GCC. 2020. GCC, the GNU Compiler Collection. http://gcc.gnu.org/onlinedocs.

Gedell, Tobias. 2005. Automating Verification of Loops by Parallelization.

Generator, CLooG: The Chunky Loop. n.d. “CLooG Site @ONLINE.” http://www.cloog.org/.

Glaskowsky, Peter N. 2009. NVIDIA’s Fermi: The First Complete GPU Computing Architecture. Whitepaper. NVIDIA. http://www.nvidia.com/content/PDF/fermi_white_papers/P.Glaskowsky_NVIDIA\%27s_Fermi-The_First_Complete_GPU_Architecture.pdf.

GNU Libgomp. 2015a. GNU libgomp, GNU Offloading and Multi Processing Runtime Library documentation (Online manual). https://gcc.gnu.org/onlinedocs/libgomp/.

GNU Libgomp. 2015b. GNU Offloading and Multi Processing Runtime Library: The GNU OpenMP and OpenACC Implementation. GNU. https://gcc.gnu.org/onlinedocs/gcc-5.2.0/libgomp.pdf.

GNU Libgomp. 2015c. GNU Offloading and Multi Processing Runtime Library: The GNU OpenMP and OpenACC Implementation. GNU libgomp. https://gcc.gnu.org/onlinedocs/gcc-5.3.0/libgomp.pdf.

GNU Libgomp. 2016b. GNU Offloading and Multi Processing Runtime Library: The GNU OpenMP and OpenACC Implementation. GNU libgomp. https://gcc.gnu.org/onlinedocs/gcc-5.4.0/libgomp.pdf.

GNU Libgomp. 2016a. GNU Offloading and Multi Processing Runtime Library: The GNU OpenMP and OpenACC Implementation. GNU libgomp. https://gcc.gnu.org/onlinedocs/gcc-6.1.0/libgomp.pdf.

Gonçalves, Rogério Aparecido. 2017. Capítulo 3: Introdução à Programação Paralela Com OpenMP: Além Das Diretivas de Compilação. ResearchGate. https://www.researchgate.net/publication/320775430_Capitulo_3_Introducao_a_Programacao_Paralela_com_OpenMP_Alem_das_Diretivas_de_Compilacao.

Gorlatch, Sergei, Martin Griebl, and Christian Lengauer. n.d. Making a Task Farm Component Parallelize Loops for the Grid.

Govindu, Gokul, Ling Zhuo, Seonil Choi, Viktor Prasanna, and Los Angeles. 2004. Analysis of High-Performance Floating-Point Arithmetic on FPGAs ∗. 00 (C).

Gpu, A M D, and The Aparapi-team. 2011. Aparapi: OpenCL in Java. no. August: 1–3.

Gpu, Fastest, Delivering Great, Gaming Performance, and True Geometric Realism. n.d. Nvidia Gf100. 1–31.

Gr, Armin. 2009a. Armin Gr¨ oßlinger. no. October.

Gr, Armin. 2009b. Precise Management of Scratchpad Memories for Localising Array Accesses in Scientific Codes. 236–50.

Grauer-Gray, Scott, Will Killian, and Louis-Noël Pouchet. 2012. PolyBench/GPU Implementation of PolyBench codes for GPU processing. http://web.cse.ohio-state.edu/~pouchet/software/polybench/GPU/.

Grauer-Gray, S., Lifan Xu, R. Searles, S. Ayalasomayajula, and J. Cavazos. 2012. “Auto-Tuning a High-Level Language Targeted to GPU Codes.” Innovative Parallel Computing (InPar), 2012, May, 1–10. https://doi.org/10.1109/InPar.2012.6339595.

GREEN500. 2013, 2014. “Ranking World’s Most Energy-Eficient Supercomputers @ONLINE.” 2013, 2014. http://www.green500.org.

Gregg, C., and K. Hazelwood. 2011. “Where Is the Data? Why You Cannot Debate CPU Vs. GPU Performance Without the Answer.” Performance Analysis of Systems and Software (ISPASS), 2011 IEEE International Symposium on, 134–44. https://doi.org/10.1109/ISPASS.2011.5762730.

Griebl, Martin. 1997. “The Mechanical Parallelization of Loop Nests Containing While Loops.” PhD thesis, Universitat Passau. http://scholar.google.com/scholar?hl=en{\&}btnG=Search{\&}q=intitle:UNIVERSITaT+PASSAU{\#}0.

Griebl, Martin. 2004. Automatic Parallelization of Loop Programs for Distributed Memory Architectures. Univ. Passau.

Griebl, Martin, Paul Feautrier, and Christian Lengauer. 2000. Index Set Splitting. no. January: 607–31.

Griebl, Martin, and Christian Lengauer. 1996. “The Loop Parallelizer LooPo.” Proc. Sixth Workshop on Compilers for Parallel Computers, Volume 21 of Konferenzen Des Forschungszentrums Jülich, 311–20.

Griebl, Martin, and Christian Lengauer. n.d. Introducing Non-Linear Parameters to the Polyhedron Model.

Griebl, M., C. Lengauer, and S. Wetzel. n.d. “Code Generation in the Polytope Model.” Proceedings. 1998 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.98EX192), 106–11. https://doi.org/10.1109/PACT.1998.727179.

Grosbach, Jim, and Owen Anderson. n.d. LLVM MC in Practice.

Grosser, Tobias. 2012. Tobias Grosser ENS - INRIA July 23, 2012 1 / 132.

GROSSER, TOBIAS, ARMIN GROESSLINGER, and CHRISTIAN LENGAUER. 2012. “POLLY - PERFORMING POLYHEDRAL OPTIMIZATIONS ON a LOW-LEVEL INTERMEDIATE REPRESENTATION.” Parallel Processing Letters 22 (04): 1250010. https://doi.org/10.1142/S0129626412500107.

Grosser, Tobias, Armin Größlinger, and Christian Lengauer. 2012. “Polly - Performing Polyhedral Optimizations on a Low-Level Intermediate Representation.” Parallel Processing Letters 22 (4).

Grosser, Tobias, and Torsten Hoefler. 2016. “Polly-ACC Transparent Compilation to Heterogeneous Hardware.” Proceedings of the 2016 International Conference on Supercomputing (New York, NY, USA), ICS ’16, 1:1–13. https://doi.org/10.1145/2925426.2926286.

Grosser, Tobias, and Andreas Simbürger. 2014. Polyhedral.info. http://polyhedral.info/.

Grosser, Tobias, and Hongbin Zheng. 2010. “Polly - Polyhedral Transformations for LLVM.”

Grosser, Tobias, Hongbin Zheng, Raghesh Aloor, Andreas Simbürger, Armin Grösslinger, and Louis-Noël Pouchet. 2011a. “Polly - Polyhedral Optimization in LLVM.” Proceedings of the First International Workshop on Polyhedral Compilation Techniques (IMPACT) 2011. http://perso.ens-lyon.fr/christophe.alias/impact2011/impact-07.pdf.

Grosser, Tobias, Hongbin Zheng, Raghesh Aloor, Andreas Simbürger, Armin Grösslinger, and Louis-Noël Pouchet. 2011b. “Polly-Polyhedral Optimization in LLVM.” Proceedings of the First International Workshop on Polyhedral Compilation Techniques (IMPACT) 2011.

Group, The Portland. 2010. PGI Accelerator Programming Model for Fortran & c. no. November.

Group, The Portland. 2013. “PGI Compiler User Guide.” http://www.pgroup.com/resources/docs.htm.

Grover, Vinod, and Sean Lee. n.d. PLANG: PTX Frontend for LLVM.

Grover, Vinod, and Yuan Lin. n.d. Compiling CUDA and Other Languages for GPUs - GTC 2012.

Guan, Haibing, Bo Liu, Zhengwei Qi, Yindong Yang, Hongbo Yang, and Alei Liang. 2010. “CoDBT: A Multi-Source Dynamic Binary Translator Using Hardware–Software Collaborative Techniques.” Journal of Systems Architecture 56 (10): 500–508. https://doi.org/10.1016/j.sysarc.2010.07.008.

Guan, Haibing, Erzhou Zhu, Hongxi Wang, Ruhui Ma, Yindong Yang, and Bin Wang. 2012. “SINOF: A Dynamic-Static Combined Framework for Dynamic Binary Translation.” Journal of Systems Architecture 58 (8): 305–17. https://doi.org/10.1016/j.sysarc.2012.05.002.

Guelton, Serge. 2012. Autotools for PIPS. 1–7.

Guelton, Serge, Mehdi Amini, Ronan Keryell, Béatrice Creusillet, Télécom Bretagne, and France Plouzané. n.d. PyPs, a Programmable Pass Manager.

Guelton, Serge, and Ronan Keryell. n.d. Compilation for Heterogeneous Computing: Automating Analyses, Transformations and Decisions.

Gustafson, John L. 1988. “Reevaluating Amdahl’s Law.” Communications of the ACM 31 (5): 532–33. https://doi.org/10.1145/42411.42415.

Haidar, Azzam, Chongxiao Cao, Asim Yarkhan, et al. 2014. “Unified Development for Mixed Multi-GPU and Multi-Coprocessor Environments Using a Lightweight Runtime Environment.” 2014 IEEE 28th International Parallel and Distributed Processing Symposium, May, 491–500. https://doi.org/10.1109/IPDPS.2014.58.

Hall, Mary. 2011. “Lecture 9: Task Parallelism in OpenMP.” www.bu.edu/tech/files/2011/09/openmp.ppt.

Han, Tianyi David, and Tarek S. Abdelrahman. 2009. “hiCUDA: A High-Level Directive-Based Language for GPU Programming.” GPGPU-2: Proceedings of 2nd Workshop on General Purpose Processing on Graphics Processing Units (New York, NY, USA), 52–61. https://doi.org/http://doi.acm.org/10.1145/1513895.1513902.

Han, Tianyi David, and Tarek S. Abdelrahman. 2011. “hiCUDA: High-Level GPGPU Programming.” IEEE Transactions on Parallel and Distributed Systems (Los Alamitos, CA, USA) 22: 78–90. https://doi.org/http://doi.ieeecomputersociety.org/10.1109/TPDS.2010.62.

Han, Wookhyun, Hwidong Bae, Hyosu Kim, Jiyoen Lee, Insik Shin, and South Korea. n.d. : Accelerating Parallelism in Multi-GPU Real-Time Systems.

Harris, Mark. 2012. CUDA 5 and Beyond.

HENNESSY, David A., John L.; PATTERSON. 2003. Arquitetura de Computadores: Uma Abordagem Quantitativa. Campus.

Heterogeneous, The, and Computing Dilemma. 2013. Irias Esearch. 1–15.

Hill, James H., and Dennis C. Feiock. 2014. “Pin++: An Object-Oriented Framework for Writing Pintools.” ACM SIGPLAN Notices 50 (3): 133–41. https://doi.org/10.1145/2775053.2658777.

Hirata, Hiroaki, Kozo Kimura, Satoshi Nagamine, et al. 1992a. “An Elementary Processor Architecture with Simultaneous Instruction Issuing from Multiple Threads.” Proceedings of the 19th Annual International Symposium on Computer Architecture (New York, NY, USA), ISCA ’92, 136–45. https://doi.org/10.1145/139669.139710.

Hirata, Hiroaki, Kozo Kimura, Satoshi Nagamine, et al. 1992b. “An Elementary Processor Architecture with Simultaneous Instruction Issuing from Multiple Threads.” SIGARCH Comput. Archit. News (New York, NY, USA) 20 (2): 136–45. https://doi.org/10.1145/146628.139710.

Holewinski, Justin. 2011. PTX Back-End: GPU Programming with LLVM.

Holewinski, Justin, Louis-Noël Pouchet, and P. Sadayappan. 2012. “High-Performance Code Generation for Stencil Computations on GPU Architectures.” Proceedings of the 26th ACM International Conference on Supercomputing - ICS ’12 (New York, New York, USA), 311. https://doi.org/10.1145/2304576.2304619.

Hong, Ding-yong, Chun-chen Hsu, Pen-chung Yew, et al. 2012. HQEMU: A Multi-Threaded and Retargetable Dynamic Binary Translator on Multicores. 104–13.

Hong, Sunpyo, and Hyesoon Kim. 2009. “An Analytical Model for a GPU Architecture with Memory-Level and Thread-Level Parallelism Awareness.” ACM SIGARCH Computer Architecture News 37 (3): 152. https://doi.org/10.1145/1555815.1555775.

Hoshino, T., N. Maruyama, S. Matsuoka, and R. Takaki. 2013. “CUDA Vs OpenACC: Performance Case Studies with Kernel Benchmarks and a Memory-Bound CFD Application.” 2013 13th IEEE/ACM International Symposium on Cluster, Cloud, and Grid Computing, May, 136–43. https://doi.org/10.1109/CCGrid.2013.12.

Hou, Yunqing, J Lai, and D Mikushin. 2011. “AsFermi: An Assembler for the NVIDIA Fermi Instruction Set.” URL: Http://Code.google.com/p/Asfermi/.

ICMC-USP. 2020. Aula 03 – Pthreads. http://wiki.icmc.usp.br/images/3/30/Aula-03-_Pthreads.pdf.

Ilic, Aleksandar, Frederico Pratas, and Leonel Sousa. 2014. “Cache-aware Roofline Model: Upgrading the Loft.” IEEE Computer Architecture Letters 13 (1): 21–24. https://doi.org/10.1109/L-CA.2013.6.

In, Rocessing. 2012. Gpgpu p. 3 (1): 105–20.

Intel. 2013. “O Coprocessador Intel(r) Xeon Phi(tm) 5110P @ONLINE.” January. http://www.intel.com.br/content/www/br/pt/processors/xeon/xeon-phi-detail.html.

Intel. 2015a. Intel® 64 and IA-32 Architectures Software Developer’s Manual. Volume 3B:system Programming Guide, Part 2. Manual. Intel. http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-3b-part-2-manual.pdf.

Intel. 2015b. Intel(r) Performance Counter Monitor - A better way to measure CPU utilization. https://software.intel.com/en-us/articles/intel-performance-counter-monitor.

Intel. 2015c. What is Code Modernization? Edited by Intel. https://software.intel.com/en-us/articles/what-is-code-modernization.

Intel. 2016a. Intel® OpenMP* Runtime Library Interface. Intel. https://www.openmprtl.org/sites/default/files/resources/libomp_20160322_manual.pdf.

Intel. 2016b. OpenMP* Support. https://software.intel.com/pt-br/node/522678.

Intel. 2019. Intel® c++ Compiler 19.1 Developer Guide and Reference. https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference.

Interprocedural, An, and Source-to-source Compiler. 2010. PIPS Tutorial.

Jablin, Thomas B., Prakash Prabhu, James A. Jablin, Nick P. Johnson, Stephen R. Beard, and David I. August. 2011a. “Automatic CPU-GPU Communication Management and Optimization.” Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (New York, NY, USA), PLDI ’11, 142–51. https://doi.org/http://doi.acm.org/10.1145/1993498.1993516.

Jablin, Thomas B., Prakash Prabhu, James A. Jablin, Nick P. Johnson, Stephen R. Beard, and David I. August. 2011b. “Automatic CPU-GPU Communication Management and Optimization.” SIGPLAN Not. (New York, NY, USA) 46: 142–51. https://doi.org/http://doi.acm.org/10.1145/1993316.1993516.

Jackson, Keith R., Lavanya Ramakrishnan, Krishna Muriki, et al. 2010. “Performance Analysis of High Performance Computing Applications on the Amazon Web Services Cloud.” 2010 IEEE Second International Conference on Cloud Computing Technology and Science, November, 159–68. https://doi.org/10.1109/CloudCom.2010.69.

Jarp, S, R Jurga, and A Nowak. 2008. “Perfmon2: A Leap Forward in Performance Monitoring.” Journal of Physics: Conference Series 119 (4): 042017. https://doi.org/10.1088/1742-6596/119/4/042017.

JCuda. 2012. “JCuda Site @ONLINE.” June. http://www.jcuda.org/.

Jimborean, Alexandra. 2012. “Adapting the polytope model for dynamic and speculative parallelization.” Theses 2012STRAD020. Université de Strasbourg. https://tel.archives-ouvertes.fr/tel-00733850.

Jin, H, M Frumkin, J Yan, and Moffett Field. 1999. The OpenMP Implementation of NAS Parallel Benchmarks and Its Performance. no. October.

JOCL. 2012. “JOCL Site @ONLINE.” June. http://www.jocl.org/documentation/documentation.html.

Johnson, Troy A., Sang-ik Lee, Long Fei, Ayon Basumallik, Rudolf Eigenmann, and Samuel P. Midkiff. 2004b. “Experiences in Using Cetus for Source-to-Source Transformations.” In Proceedings of the 17th International Workshop on Languages and Compilers for Parallel Computing (LCPC.

Johnson, Troy A., Sang-ik Lee, Long Fei, Ayon Basumallik, Rudolf Eigenmann, and Samuel P. Midkiff. 2004a. “Experiences in Using Cetus for Source-to-Source Transformations.” In Proceedings of the 17th International Workshop on Languages and Compilers for Parallel Computing (LCPC.

Johnson, Troy A, Sang-ik Lee, Long Fei, Ayon Basumallik, Rudolf Eigenmann, and Samuel P Midkiff. n.d. Experiences in Using Cetus for Source-to-Source Transformations ⋆. no. 9703180.

Jones, Stephen. n.d. Introduction to Dynamic Parallelism.

Joshi, Shrinivas, and Software Performance Engineer. n.d. Leveraging Aparapi to Help Improve Financial Java Application Performance.

Journal, International, Parallel Programming, Received November, Accepted February, Woodfield Drive, and Computer Science. 1987. Loop Skewing: The Wavefront Method Revisited. 15 (4): 279–93.

Jouvelot, Pierre, and Rémi Triolet. 1989. “Newgen: A Language Independent Program Generator.” Rapport Interne CAII 191: 4.

Jovanovic, S., C. Tanougast, and S. Weber. 2007. “A Hardware Preemptive Multitasking Mechanism Based on Scan-Path Register Structure for FPGA-Based Reconfigurable Systems.” Second NASA/ESA Conference on Adaptive Hardware and Systems (AHS 2007), no. Ahs (August): 358–64. https://doi.org/10.1109/AHS.2007.4.

Jovanović, Ž., and V. Milutinović. 2012. “FPGA Accelerator for Floating-Point Matrix Multiplication.” IET Computers & Digital Techniques 6 (4): 249. https://doi.org/10.1049/iet-cdt.2011.0132.

Jozwik, Krzysztof, Hiroyuki Tomiyama, Shinya Honda, and Hiroaki Takada. 2010. “A Novel Mechanism for Effective Hardware Task Preemption in Dynamically Reconfigurable Systems.” 2010 International Conference on Field Programmable Logic and Applications, August, 352–55. https://doi.org/10.1109/FPL.2010.76.

Jul, Thu, Fri Dec, and Fri Apr. 2013. Intel ® OpenMP * Runtime Library.

Kalaiselvi, S., and V. Rajaraman. 2000. “A Survey of Checkpointing Algorithms for Parallel and Distributed Computers.” Sadhana 25 (5): 489–510. https://doi.org/10.1007/BF02703630.

Kennedy, Ken, and John R. Allen. 2002. Optimizing Compilers for Modern Architectures: A Dependence-Based Approach. Morgan Kaufmann Publishers Inc.

Khaldi, Dounia, and Corinne Ancourt. n.d. Towards Automatic c Programs Optimization and Parallelization Using the PIPS-PoCC Integration.

Khronos. 2013a. OpenCL - The open standard for parallel programming of heterogeneous systems. http://www.khronos.org/opencl/.

Khronos. 2013b. “OpenCL - the Open Standard for Parallel Programming of Heterogeneous Systems @ONLINE.” January. http://www.khronos.org/opencl/.

Kim, Ki-Hwan, KyoungHo Kim, and Q-Han Park. 2011. “Performance analysis and optimization of three-dimensional FDTD on GPU using roofline model.” Computer Physics Communications 182 (6): 1201–7. https://doi.org/10.1016/j.cpc.2011.01.025.

Kinsman, Phillip, and Nicola Nicolici. 2011. “Dynamic Binary Translation to a Reconfigurable Target for on-the-Fly Acceleration.” Proceedings of the 48th Design Automation Conference on - DAC ’11 (New York, New York, USA), 286. https://doi.org/10.1145/2024724.2024792.

Kirk, David B., and Wen-mei W. Hwu. 2010b. Programming Massively Parallel Processors: A Hands-on Approach. 1st ed. Paperback; Morgan Kaufmann. http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20&path=ASIN/0123814723.

Kirk, David B., and Wen-mei W. Hwu. 2010a. Programming Massively Parallel Processors: A Hands-on Approach. 1st ed. Paperback; Morgan Kaufmann. http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20&path=ASIN/0123814723.

Kirk, David B., and Wen-mei W. Hwu. 2010c. Programming Massively Parallel Processors: A Hands-on Approach. 1st ed. Paperback; Morgan Kaufmann Publishers Inc. http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20&path=ASIN/0123814723.

Klöckner, Andreas, Nicolas Pinto, Yunsup Lee, B. Catanzaro, Paul Ivanov, and Ahmed Fasih. 2012. “PyCUDA and PyOpenCL: A Scripting-Based Approach to GPU Run-Time Code Generation.” Parallel Computing 38 (3): 157–74. https://doi.org/10.1016/j.parco.2011.09.001.

Knuth, Donald E. 1984. “Literate Programming.” Comput. J. 27 (2): 97–111. https://doi.org/10.1093/comjnl/27.2.97.

Koch, D., A. Ahmadinia, C. Bobda, and H. Kalte. n.d. “FPGA Architecture Extensions for Preemptive Multitasking and Hardware Defragmentation.” Proceedings. 2004 IEEE International Conference on Field- Programmable Technology (IEEE Cat. No.04EX921), 433–36. https://doi.org/10.1109/FPT.2004.1393318.

Konstantinidis, Elias, and Yiannis Cotronis. 2015. “A Practical Performance Model for Compute and Memory Bound GPU Kernels.” 2015 23rd Euromicro International Conference on Parallel, Distributed, and Network-Based Processing, March, 651–58. https://doi.org/10.1109/PDP.2015.51.

Korn, W., P. J. Teller, and G. Castillo. 2001. “Just How Accurate Are Performance Counters?” Conference Proceedings of the 2001 IEEE International Performance, Computing, and Communications Conference (Cat. No.01CH37210), 303–10. https://doi.org/10.1109/IPCCC.2001.918667.

Krawezik, Géraud, and Franck Cappello. 2006. “Performance Comparison of MPI and OpenMP on Shared Memory Multiprocessors.” Concurrency and Computation: Practice and Experience 18 (1): 29–61. https://doi.org/10.1002/cpe.905.

Kumar, Uday, Reddy Bondhugula, and Dissertation Committee. 2008. Effective Automatic Parallelization and Locality Optimization Using the Polyhedral Model.

Kyle, Stephen, Igor Böhm, Björn Franke, Hugh Leather, and Nigel Topham. 2012. “Efficiently Parallelizing Instruction Set Simulation of Embedded Multi-Core Processors Using Region-Based Just-in-Time Dynamic Binary Translation.” Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems - LCTES ’12 (New York, New York, USA), 21. https://doi.org/10.1145/2248418.2248422.

Labarta, Jesus. 2010. StarSs: A Programming Model for the Multicore Era. 1–35.

Lam, S, and E Wolf. 1991. A Data Locality. 30–44.

Lameed, Nurudeen Abiodun. 2013. Dynamic Compiler Optimization Techniques for Matlab. no. April.

Landau, LD. 1937. “No Title.” Zhurnal Eksperimental’noi i Teoreticheskoi Fiziki, no. April. http://scholar.google.com/scholar?hl=en{\&}btnG=Search{\&}q=intitle:No+Title{\#}0.

Lattner, Chris. 2008. “LLVM and Clang: Next Generation Compiler Technology.” The BSD Conference, Ottawa, Canada.

Lattner, Chris, and Vikram Adve. 2004. “LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation.” Proceedings of the 2004 International Symposium on Code Generation and Optimization (CGO’04) (Palo Alto, California), March.

Lattner, Chris, Vikram Adve, and David Koes. n.d. The LLVM Compiler Framework and Infrastructure (Part 1). nos. Part 1: 1–31.

Layer, Compute Abstraction. 2010. Programming AMD. no. December.

Lee, E A. 2006. “The Problem with Threads.” Computer 39 (5): 33–42. https://doi.org/10.1109/MC.2006.180.

Lee, Kyu-Yean, Seong-Jin Cho, Seung-Hyun Yoon, and Jae-Wook Jeon. 2015. “Roofline measurement application.” Proceedings of the 9th International Conference on Ubiquitous Information Management and Communication - IMCOM ’15 (New York, New York, USA), January, 1–6. https://doi.org/10.1145/2701126.2701150.

Lee, Sang-ik, Troy A. Johnson, and Rudolf Eigenmann. 2003b. “Cetus - an Extensible Compiler Infrastructure for Source-to-Source Transformation.” Languages and Compilers for Parallel Computing, 16th Intl. Workshop, College Station, TX, USA, Revised Papers, Volume 2958 of LNCS, 539–53.

Lee, Sang-ik, Troy A. Johnson, and Rudolf Eigenmann. 2003a. “Cetus - an Extensible Compiler Infrastructure for Source-to-Source Transformation.” Languages and Compilers for Parallel Computing, 16th Intl. Workshop, College Station, TX, USA, Revised Papers, Volume 2958 of LNCS, 539–53.

Lee, Sangpil, and Won Woo Ro. 2013. “Parallel GPU Architecture Simulation Framework Exploiting Work Allocation Unit Parallelism.” 2013 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), April, 107–17. https://doi.org/10.1109/ISPASS.2013.6557151.

Lee, Seung J, David K Raila, and Volodymyr V Kindratenko. 2008. Compilation Environment for FPGAs Using LLVM Compiler Infrastructure and CHiMPS Computational Model.

Lee, Seyong, and Rudolf Eigenmann. 2010b. “OpenMPC: Extended OpenMP Programming and Tuning for GPUs.” Proceedings of the 2010 ACM/IEEE International Conference for High Performance Computing, Networking, Storage and Analysis (Washington, DC, USA), SC ’10, 1–11. https://doi.org/10.1109/SC.2010.36.

Lee, Seyong, and Rudolf Eigenmann. 2010a. “OpenMPC: Extended OpenMP Programming and Tuning for GPUs.” Proceedings of the 2010 ACM/IEEE International Conference for High Performance Computing, Networking, Storage and Analysis (Washington, DC, USA), SC ’10, 1–11. https://doi.org/10.1109/SC.2010.36.

Lee, Seyong, Seung-Jai Min, and Rudolf Eigenmann. 2009. “OpenMP to GPGPU: A Compiler Framework for Automatic Translation and Optimization.” PPoPP ’09: Proceedings of the 14th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 101–10.

Lee, Seyong, Jeffrey Vetter, and Rudolf Eigenmann. n.d. OpenMPC: OpenMP Extended for CUDA.

Lee, Victor W., Per Hammarlund, Ronak Singhal, et al. 2010. “Debunking the 100X GPU Vs. CPU Myth.” ACM SIGARCH Computer Architecture News 38 (3): 451. https://doi.org/10.1145/1816038.1816021.

Lengauer, C. 1993. “Loop Parallelization in the Polytope Model.” In CONCUR’93, edited by E. Best. Lecture Notes in Computer Science 715. Springer-Verlag.

Lengauer, Christian. n.d. Extending Loop Parallelization for the Grid to Largely Decentralized Communication.

Lengauer, Christian, and Martin Griebl. 1995. “On the Parallelization of Loop Nests Containing While Loops.” Proc. 1st Aizu Int. Symp. On Parallel Algorithm/Architecture Synthesis (pAs’95, 10–18.

Lengauer, Christian, and Universitat Passau. n.d. Loop Parallelization in the Polytope Model. 1–19.

Levinson, L., R. Manner, M. Sessler, and H. Simmler. 2000. “Preemptive Multitasking on FPGAs.” Proceedings 2000 IEEE Symposium on Field-Programmable Custom Computing Machines (Cat. No.PR00871), 301–2. https://doi.org/10.1109/FPGA.2000.903426.

libgomp. 2015. “GNU Libgomp.” https://gcc.gnu.org/onlinedocs/libgomp/.

Libgomp, GNU N U. 2015. GNU Offloading and Multi Processing Runtime Library: The GNU OpenMP and OpenACC Implementation. GNU libgomp. https://gcc.gnu.org/onlinedocs/gcc-5.2.0/libgomp.pdf.

Lin, Yuan. n.d. Building GPU Compilers with libNVVM | GTC 2013.

LLVM OpenMP. 2015. OpenMP®: Support for the OpenMP Language. http://openmp.llvm.org/.

LLVM, Projeto. 2013. “The LLVM Compiler Infrastructure Site @ONLINE.” http://llvm.org.

Lo, YuJung, Samuel Williams, Brian Van Straalen, et al. 2015. “Roofline Model Toolkit: A Practical Tool for Architectural and Program Analysis.” In High Performance Computing Systems. Performance Modeling, Benchmarking, and Simulation, edited by Stephen A. Jarvis, Steven A. Wright, and Simon D. Hammond, vol. 8966. Lecture Notes in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-17248-4_7.

Lomüller, Victor, and Henri-Pierre Charles. 2014. “A LLVM Extension for the Generation of Low Overhead Runtime Program Specializer.” Proceedings of International Workshop on Adaptive Self-Tuning Computing Systems - ADAPT ’14 (New York, New York, USA), January, 14–16. https://doi.org/10.1145/2553062.2553064.

Lomüller, Victor, Sylvestre Ledru, and Henri-Pierre Charles. 2013. “Scilab on a Hybrid Platform.” PARCO, 743–52.

Lopes, Luı́s, Julius Žilinskas, Alexandru Costan, et al., eds. 2014. Euro-Par 2014: Parallel Processing Workshops. Vol. 8806. Lecture Notes in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-14313-2.

Lopez-rodriguez, Ivan. n.d. Improving OpenACC Compatibility Within accULL.

Lorenzo, O G, T F Pena, J C Cabaleiro, J C Pichel, and F F Rivera. 2013. “DyRM: A Dynamic Roofline Model Based on Runtime Information.” 2013 International Conference on Computational and Mathematical Methods in Science and Engineering, 965–67. http://citius.usc.es/investigacion/publicacions/listado/490.

Lorenzo, O. G., T. F. Pena, J. C. Cabaleiro, J. C. Pichel, and F. F. Rivera. 2014a. “3DyRM: a dynamic roofline model including memory latency information.” The Journal of Supercomputing 70 (2): 696–708. https://doi.org/10.1007/s11227-014-1163-4.

Lorenzo, O. G., T. F. Pena, J. C. Cabaleiro, J. C. Pichel, and F. F. Rivera. 2014b. “Multiobjective Optimization Technique Based on Monitoring Information to Increase the Performance of Thread Migration on Multicores.” 2014 IEEE International Conference on Cluster Computing (CLUSTER), September, 416–23. https://doi.org/10.1109/CLUSTER.2014.6968733.

Lorenzo, Oscar G, Tomás F Pena, José C Cabaleiro, Juan C Pichel, and Francisco Fernández Rivera. 2014. “Using an Extended Roofline Model to Understand Data and Thread Affinities on NUMA Systems.” Annals of Multicore and GPU Programming 1 (1): 56–67.

Ltaief, Hatem, and Stanimire Tomov. n.d. Solving Linear Algebra Algorithms Using Multiple GPU Accelerators.

Lu, Shan, Soyeon Park, Eunsoo Seo, and Yuanyuan Zhou. 2008. “Learning from Mistakes: A Comprehensive Study on Real World Concurrency Bug Characteristics.” SIGARCH Comput. Archit. News (New York, NY, USA) 36 (1): 329–39. https://doi.org/10.1145/1353534.1346323.

Luk, Chi-keung, Robert Muth, Harish Patil, et al. 2004. Ispike: A Post-Link Optimizer for the Intel Itanium Architecture. no. Cgo.

Lustig, D., and M. Martonosi. 2013. “Reducing GPU Offload Latency via Fine-Grained CPU-GPU Synchronization.” 2013 IEEE 19th International Symposium on High Performance Computer Architecture (HPCA), February, 354–65. https://doi.org/10.1109/HPCA.2013.6522332.

Ma, Kai, Xue Li, Wei Chen, Chi Zhang, and Xiaorui Wang. 2012. “GreenGPU: A Holistic Approach to Energy Efficiency in GPU-CPU Heterogeneous Architectures.” 2012 41st International Conference on Parallel Processing, September, 48–57. https://doi.org/10.1109/ICPP.2012.31.

Mado, Branislav, and Anton Bal. 2011. Data Flow Graph Mapping Techniques of Computer Architecture with Data Driven Computation Model. 355–59.

Malhotra, M., and London Sw. 2003. “Optimizing the Execution of Independent Multi-Version Programs.” 22nd Digital Avionics Systems Conference Proceedings (Cat No 03CH37449) DASC-03 2: 10.A.4–10.1. https://doi.org/10.1109/DASC.2003.1245930.

Malony, AD., S. Biersdorff, S. Shende, et al. 2011. “Parallel Performance Measurement of Heterogeneous Parallel Systems with GPUs.” Parallel Processing (ICPP), 2011 International Conference on, 176–85. https://doi.org/10.1109/ICPP.2011.71.

Malony, Allen D., Scott Biersdorff, Sameer Shende, et al. 2011. “Parallel Performance Measurement of Heterogeneous Parallel Systems with GPUs.” 2011 International Conference on Parallel Processing, September, 176–85. https://doi.org/10.1109/ICPP.2011.71.

Mannert, R, M Sesslert, and H Simmlert. 2000. Multitasking on FPGAs*.

Manual, A P I Reference. 2013. Libnvvm Api. no. July.

Manual, Compiler Reference. n.d. The Portland Group.

Mark, Bill, and Kekoa Proudfoot. 2001. Shading Languages for Graphics Hardware.

Marowka, A. 2008. “Think Parallel: Teaching Parallel Programming Today.” Distributed Systems Online, IEEE 9 (8): 1. https://doi.org/10.1109/MDSO.2008.24.

Marr, Deborah T., Frank Binns, David L. Hill, et al. 2002. “Hyper-Threading Technology Architecture and Microarchitecture.” Intel Technology Journal 6 (1): 4–15.

Martinez, G., M. Gardner, and Wu-chun Feng. 2011a. “CU2CL: A CUDA-to-OpenCL Translator for Multi- and Many-Core Architectures.” Parallel and Distributed Systems (ICPADS), 2011 IEEE 17th International Conference on, 300–307. https://doi.org/10.1109/ICPADS.2011.48.

Martinez, G., M. Gardner, and Wu-chun Feng. 2011c. “CU2CL: A CUDA-to-OpenCL Translator for Multi- and Many-Core Architectures.” Parallel and Distributed Systems (ICPADS), 2011 IEEE 17th International Conference on, 300–307. https://doi.org/10.1109/ICPADS.2011.48.

Martinez, G., M. Gardner, and Wu-chun Feng. 2011b. “CU2CL: A CUDA-to-OpenCL Translator for Multi- and Many-Core Architectures.” Parallel and Distributed Systems (ICPADS), 2011 IEEE 17th International Conference on, 300–307. https://doi.org/10.1109/ICPADS.2011.48.

Mathur, W., and J. Cook. n.d. “Improved Estimation for Software Multiplexing of Performance Counters.” 13th IEEE International Symposium on Modeling, Analysis, and Simulation of Computer and Telecommunication Systems, 23–34. https://doi.org/10.1109/MASCOTS.2005.34.

Matloff, Norman. 2006. “Introduction to OpenMP. Dijkstra Sample.” http://heather.cs.ucdavis.edu/{~}matloff/openmp.html{\#}tutorials.

Mattson, Timothy G. 2003. “How Good Is OpenMP.” Scientific Programming 11 (2): 81–93. https://doi.org/10.1155/2003/124373.

Maxwell, Featuring First-generation, G P U Technology, and Extreme Performance. n.d. NVIDIA GeForce GTX 750 Ti. 1–11.

May, J. M. 2001. “MPX: Software for Multiplexing Hardware Performance Counters in Multithreaded Programs.” Proceedings 15th International Parallel and Distributed Processing Symposium. IPDPS 2001, April, 8. https://doi.org/10.1109/IPDPS.2001.924955.

Maziero, Carlos Alberto. 2017. Sistemas Operacionais: Conceitos e Mecanismos. Online.

Michael Graf, David Bunde, Andrei Papancea. 2012. Cilk Tutorial. http://faculty.knox.edu/dbunde/teaching/cilk/.

Micikevicius, Paulius. 2011. Multi-GPU Programming.

Micikevicius, Paulius. n.d. Optimizing CUDA.

Midkiff, Samuel P. 2012. Automatic Parallelization: An Overview of Fundamental Compiler Techniques. Morgan & Claypool Publishers.

Mikushin, D., N. Likhogrud, E. Z. Zhang, and C. Bergstrom. 2014. “KernelGen – The Design and Implementation of a Next Generation Compiler Platform for Accelerating Numerical Models on GPUs.” Parallel Distributed Processing Symposium Workshops (IPDPSW), 2014 IEEE International, May, 1011–20. https://doi.org/10.1109/IPDPSW.2014.115.

Mikushin, Dmitry, and Sergey Kovylov. 2012. Designing Parallel GPU Kernels Generator Based on LLVM and NVPTX Backend for the COSMO Model.

Mikushin, Dmitry, Sergey Kovylov, and Nikolay Likhogrud. 2013. KernelGen – A prototype of auto-parallelizing Fortran/C compiler for NVIDIA GPUs. 5.

Mikushin, Dmitry, and Nicolas Likhogrud. 2012. KERNELGEN - a Toolchain for Automatic GPU-Centric Applications Porting. http://hgpu.org/?p=8313.

Mikushin, Dmitry, Nikolay Likhogrud, and Sergey Kovylov. n.d. KernelGen: Auto-Parallelizing Fortran/c Compiler | GTC 2013.

Mikushin, Dmitry, Nikolay Likhogrud, and Hou Yunqing. 2012. KernelGen – a Prototype of Auto-Parallelizing Compiler for NVIDIA GPUs.

Mikushin, Dmitry, Nikolay Likhogrud, and Eddy Zheng Zhang. 2013a. “KERNELGEN - the design and implementation of a next generation compiler platform for accelerating numerical models on GPUs.” In Rutgers Technical Reports. Rutgers.

Mikushin, Dmitry, Nikolay Likhogrud, and Eddy Zheng Zhang. 2013b. “KERNELGEN - the Design and Implementation of a Next Generation Compiler Platform for Accelerating Numerical Models on GPUs.” Rutgers Technical Reports.

Mikushin, Dmitry, Nikolay Likhogrud, Eddy Zheng Zhang, and Christopher Bergström. 2013. KernelGen – the Design and Implementation of a Next Generation Compiler Platform for Accelerating Numerical Models on GPUs. Technical Report 2013/02, University of Lugano, July 2013. http://www.old.inf.usi.ch/file/pub/75/tech_report2013. pdf.

Miller, David J., Philip M. Watts, and Andrew W. Moore. 2009. “Motivating Future Interconnects.” Proceedings of the 5th ACM/IEEE Symposium on Architectures for Networking and Communications Systems - ANCS ’09 (New York, New York, USA), October, 94. https://doi.org/10.1145/1882486.1882513.

Mohr, Bernd, Allen D. Malony, Sameer Shende, and Felix Wolf. 2002. “Design and Prototype of a Performance Tool Interface for OpenMP.” The Journal of Supercomputing (Hingham, MA, USA) 23 (1): 105–28. https://doi.org/10.1023/A:1015741304337.

Moseley, Tipp, Daniel a. Connors, Dirk Grunwald, and Ramesh Peri. 2007. “Identifying Potential Parallelism via Loop-Centric Profiling.” Proceedings of the 4th International Conference on Computing Frontiers - CF ’07 (New York, New York, USA), 143. https://doi.org/10.1145/1242531.1242554.

Mulati, Mauro Henrique. n.d. Um Algoritmo ACO Paralelo Para ˜ o de Grafos Colorac ¸ a.

Nath, Rajib, Stanimire Tomov, and Jack Dongarra. 2010. Accelerating GPU Kernels for Dense Linear Algebra. June, 83–92. http://dl.acm.org/citation.cfm?id=1964238.1964250.

Newburn, Chris J., Rajiv Deodhar, Serguei Dmitriev, et al. 2013. “Offload Compiler Runtime for the Intel(r) Xeon Phi(tm) Coprocessor.” In Supercomputing: 28th International Supercomputing Conference, ISC 2013, Leipzig, Germany, June 16-20, 2013. Proceedings, edited by Julian Martin Kunkel, Thomas Ludwig, and Hans Werner Meuer. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38750-0_18.

Ni, Tianyun. 2009. “Direct Compute–Bring GPU Computing to the Mainstream.” GPU Technology Conference.

Nichols, Bradford, Dick Buttlar, and Jacqueline Proulx Farrell. 1996. Pthreads Programming - a POSIX Standard for Better Multiprocessing. O’Reilly.

Nickolls, John, and David Kirk. n.d. Graphics and Computing GPUs.

Nielson, Hanne Riis. 2005. Principles of Program Analysis: A Sampler of Approaches. no. May.

Nowak, A., and G. Bitzes. 2014. The Overhead of Profiling Using PMU Hardware Counters. CERN Openlab Report 2014. CERN. http://openlab.web.cern.ch/publications/technical_documents/overhead-profiling-using-pmu-hardware-counters.

Nowak, Andrzej, and Georgios Bitzes. 2014. The Overhead of Profiling Using PMU Hardware Counters. CERN Openlab Report 2014. CERN. https://doi.org/10.5281/zenodo.10800.

Number, Reference. 2012. Intel ® Xeon Phi ™ Coprocessor Instruction Set Architecture Reference Manual.

NVIDIA. 2009a. NVIDIA CUDA C Programming Best Practices Guide. NVIDIA.

NVIDIA. 2009b. NVIDIA CUDA c Programming Best Practices Guide. NVIDIA.

NVIDIA. 2009c. Whitepaper: NVIDIA’s Next Generation CUDA(tm) Compute Architecture: Fermi(tm). Version 1.1. NVIDIA. http://www.nvidia.com/content/PDF/fermi_white_papers/NVIDIA_Fermi_Compute_Architecture_Whitepaper.pdf.

NVIDIA. 2012. NVIDIA’s Next Generation CUDA Compute Architecture: Kepler GK110. NVIDIA Corporation. http://www.nvidia.com/content/PDF/kepler/NVIDIA-Kepler-GK110-Architecture-Whitepaper.pdf.

NVIDIA. 2013a. LIBNVVM API: API Reference Manual. NVIDIA. http://http://docs.nvidia.com/cuda/libnvvm-api.

NVIDIA. 2013b. NVIDIA CUDA c Programming Best Practices Guide. NVIDIA.

NVIDIA. 2013c. NVIDIA CUDA c Programming Best Practices Guide. NVIDIA.

NVIDIA. 2013d. NVML API Reference Manual. NVIDIA. https://developer.nvidia.com/nvidia-management-library-nvml.

NVIDIA. 2013e. NVML API REFERENCE MANUAL. NVIDIA. https://developer.nvidia.com/nvidia-management-library-nvml.

NVIDIA. 2014a. cuBLAS-XT: Accelerate BLAS calls with multiple GPUs. http://developer.nvidia.com/cublasxt.

NVIDIA. 2014b. CUDA c BEST PRACTICES GUIDE. DG-05603-001_v6.5. NVIDIA. http://docs.nvidia.com/cuda/pdf/CUDA_C_Best_Practices_Guide.pdf.

NVIDIA. 2014c. CUDA c PROGRAMMING GUIDE. PG-02829-001. NVIDIA. http://docs.nvidia.com/cuda/pdf/CUDA_C_Programming_Guide.pdf.

NVIDIA. 2014d. CUPTI User’s Guide.

NVIDIA. 2014e. CUPTI Users Guide \(CUDA Performance Tools Interface\). NVIDIA. http://docs.nvidia.com/cuda/cupti.

NVIDIA. 2014f. Maxwell Compatibility Guide for CUDA Applications. February. DA-07172-0.

NVIDIA. 2014g. Whitepaper: NVIDIA GeForce GTX 750 Ti. Featuring First-Generation Maxwell GPU Technology, Designed for Extreme Performance Per Watt. NVIDIA Corporation. http://international.download.nvidia.com/geforce-com/international/pdfs/GeForce-GTX-750-Ti-Whitepaper.pdf.

NVIDIA. 2015a. cuBLAS: NVIDIA CUDA Basic Linear Algebra Subroutines. https://developer.nvidia.com/cublas.

NVIDIA. 2015b. CUDA C Best Practices Guide. NVIDIA. http://docs.nvidia.com/cuda/cuda-c-best-practices-guide.

NVIDIA. 2015c. CUDA DEBUGGER API: API Reference Manual. Tech Report: TRM-06710-001 \_v7.0. NVIDIA. http://docs.nvidia.com/cuda/pdf/CUDA\_Debugger\_API.pdf.

NVIDIA. 2015d. CUPTI User’s Guide. NVIDIA.

Nvidia, Whitepaper, Next Generation, and Cuda Compute. n.d. Whitepaper NVIDIA’s Next Generation CUDA Compute Architecture: 1–22.

NVPTX, LLVM. 2013. “User Guide for NVPTX Back-End @ONLINE.” July. http://llvm.org/docs/NVPTXUsage.html.

Of, Octor. n.d. Ptimization in the.

Ofenbeck, Georg, Ruedi Steinmann, Victoria Caparros, Daniele G. Spampinato, and Markus Puschel. 2014. “Applying the roofline model.” 2014 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), March, 76–85. https://doi.org/10.1109/ISPASS.2014.6844463.

Ofenbeck, Georg, Ruedi Steinmann, Victoria Caparrós Cabezas, Daniele G. Spampinato, and Markus Püschel. 2014. “Applying the Roofline Model.” 2014 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS) 2014, Monterey, CA, USA, March 23-25, 2014, 76–85. https://doi.org/10.1109/ISPASS.2014.6844463.

Okuda, Kunio. 1996. Encolhimento de Ciclo Por Redução de Dependência. http://www.lbd.dcc.ufmg.br/colecoes/sbac-pad/1995/0036.pdf.

Okur, Semih, and Danny Dig. 2012. “How Do Developers Use Parallel Libraries?” Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering, 54.

Olofsson, Andreas. 2013. Parallella: A Love Story. 1–19.

Olukotun, Kunle, Basem A. Nayfeh, Lance Hammond, Ken Wilson, and Kunyung Chang. 1996a. “The Case for a Single-Chip Multiprocessor.” Proceedings of the Seventh International Conference on Architectural Support for Programming Languages and Operating Systems (New York, NY, USA), ASPLOS VII, 2–11. https://doi.org/10.1145/237090.237140.

Olukotun, Kunle, Basem A. Nayfeh, Lance Hammond, Ken Wilson, and Kunyung Chang. 1996b. “The Case for a Single-Chip Multiprocessor.” SIGPLAN Not. (New York, NY, USA) 31 (9): 2–11. https://doi.org/10.1145/248209.237140.

OpenACC. 2011a. OpenACC Application Programming Interface. Version 1.0. http://www.openacc.org/sites/default/files/OpenACC.1.0_0.pdf.

OpenACC. 2011b. “OpenACC Application Programming Interface. Version 1.0. @ONLINE.” November. http://www.openacc.org/sites/default/files/OpenACC.1.0\_0.pdf.

OpenACC. 2012. OpenACC Directives for Accelerators Site. http://www.openacc-standard.org/.

OpenACC. 2013. OpenACC Application Programming Interface. Version 2.0. http://www.openacc.org/sites/default/files/OpenACC.2.0a_1.pdf.

OpenACC. 2015a. OpenACC Application Programming Interface. Version 2.5. http://www.openacc.org/sites/default/files/OpenACC_2pt5.pdf.

OpenACC. 2015b. OpenACC Directives for Accelerators. http://www.openacc.org/.

OpenMP API Site. 2020. The OpenMP(r) API Specification for Parallel Programming. http://openmp.org.

OpenMP Architecture Review Board. 2021. OpenMP Application Programming Interface. https://www.openmp.org.

OpenMP, Site. 2012. “OpenMP Site @ONLINE.” January. http://openmp.org.

OpenmpAndFork. 2008. “Guide into OpenMP: Easy Multithreading Programming for c++.” http://bisqwit.iki.fi/story/howto/openmp/{\#}OpenmpAndFork.

OpenMP-ARB. 2011. OpenMP Application Program Interface Version 3.1. OpenMP Architecture Review Board (ARB). http://www.openmp.org/mp-documents/OpenMP3.1.pdf.

OpenMP-ARB. 2013. OpenMP Application Program Interface Version 4.0. OpenMP Architecture Review Board (ARB). http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf.

OpenMP-ARB. 2014. OpenMP Application Program Interface Examples 4.0.1. OpenMP Architecture Review Board (ARB). http://openmp.org/mp-documents/OpenMP_Examples_4.0.1.pdf.

OpenMP-ARB. 2015. OpenMP Application Program Interface Version 4.5. OpenMP Architecture Review Board (ARB). http://www.openmp.org/mp-documents/openmp-4.5.pdf.

Ottoni, Guilherme, Thomas Hartin, Christopher Weaver, Jason Brandt, Belliappa Kuttanna, and Hong Wang. n.d. Harmonia: A Transparent, Efficient, and Harmonious Dynamic Binary Translator Targeting the Intel Architecture.

Owaida, Muhsen, Nikolaos Bellas, Konstantis Daloukas, and Christos D. Antonopoulos. 2011. “Synthesis of Platform Architectures from OpenCL Programs.” 2011 IEEE 19th Annual International Symposium on Field-Programmable Custom Computing Machines, May, 186–93. https://doi.org/10.1109/FCCM.2011.19.

Owens, J. D., M. Houston, D. Luebke, S. Green, J. E. Stone, and J. C. Phillips. 2008. “GPU Computing.” Proceedings of the IEEE 96 (5): 879–99. https://doi.org/10.1109/JPROC.2008.917757.

Owens, Shubhabrata Sengupta AND Mark Harris AND Yao Zhang AND John D. 2007. “Scan Primitives for GPU Computing.” Graphics Hardware 2007 (San Diego, CA), August, 97–106.

Paae, M. 1991. C’omputer NASA MS Moffett. 412–23.

Padua, David a., and Michael J. Wolfe. 1986. “Advanced Compiler Optimizations for Supercomputers.” Communications of the ACM 29 (12): 1184–201. https://doi.org/10.1145/7902.7904.

Pai, Sreepathi, Matthew J. Thazhuthaveetil, and R. Govindarajan. 2013. “Improving GPGPU Concurrency with Elastic Kernels.” ACM SIGPLAN Notices 48 (4): 407. https://doi.org/10.1145/2499368.2451160.

Papakonstantinou, Alexandros, Karthik Gururaj, John a. Stratton, Deming Chen, Jason Cong, and Wen-Mei W. Hwu. 2009a. “FCUDA: Enabling Efficient Compilation of CUDA Kernels onto FPGAs.” 2009 IEEE 7th Symposium on Application Specific Processors, July, 35–42. https://doi.org/10.1109/SASP.2009.5226333.

Papakonstantinou, Alexandros, Karthik Gururaj, John a. Stratton, Deming Chen, Jason Cong, and Wen-Mei W. Hwu. 2009b. “High-Performance CUDA Kernel Execution on FPGAs.” Proceedings of the 23rd International Conference on Conference on Supercomputing - ICS ’09 (New York, New York, USA), 515. https://doi.org/10.1145/1542275.1542357.

PAPI. 2015. “Counting Floating Point Operations on Intel Sandy Bridge and Ivy Bridge.” http://icl.cs.utk.edu/projects/papi/wiki/PAPITopics:SandyFlops.

Par4All, Site. 2012. “Par4All Developer Guide @ONLINE.” http://www.par4all.org/documentation/developers-guide/.

Parallelism, Dynamic, and U All. n.d. Dynamic Parallelism in Cuda.

Parallelization, I Basic. n.d. Lecture 12. 1–10.

Parallware. 2014. “Parallware: The OpenMP-Enabling Source-to-Source Compiler.” http://www.appentra.com/parallel-computation-pi.

Passau, Universitat. n.d. On the Space-Time Mapping of While-Loops.

Patterson, David. 2009. “The Top 10 Innovations in the New NVIDIA Fermi Architecture, and the Top 3 Next Challenges.” NVIDIA Whitepaper.

PATTERSON, John L., David A.; HENNESSY. 2005. Organização e Projeto de Computadores: A Interface Hardware/Software. Campus.

Pessoa, Tiago Carneiro. 2006. Exploiting CUDA Dynamic Parallelism for Improving Parallel Backtracking Algorithms on GPUs.

PGROUP, The Portland Group. 2010. PGI User’s Guide. http://www.pgroup.com/resources/docs.htm.

PGROUP, The Portland Group. 2013. PGI(r) Compiler Reference Manual. Parallel Fortran, C and C++ for Scientists and Engineers. http://www.pgroup.com/resources/docs.htm.

PGROUP, The Portland Group. 2015. PGI Accelerator Compilers with OpenACC Directives. http://www.pgroup.com/resources/accel.htm.

Philip J. Mucci, Shirley Browne, Christine Deane, George Ho, Philip J Mucci, Shirley Browne, Christine Deane, and George Ho. 1999. “PAPI: A Portable Interface to Hardware Performance Counters.” In Proceedings of the Department of Defense HPCMP Users Group Conference, 7–10. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.117.6801.

PIPS, Site. 2012. “The PIPS Workbench Project @ONLINE.” http://www.cri.ensmp.fr/pips/.

Pllana, Sabri, Siegfried Benkner, Eduard Mehofer, Lasse Natvig, and Fatos Xhafa. 2009. “Towards an Intelligent Environment for Programming Multi-Core Computing Systems.” In Euro-Par 2008 Workshops - Parallel Processing, edited by Eduardo César, Michael Alexander, Achim Streit, et al., vol. 5415. Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-00955-6_19.

Point, Rond, Benjamin Franklin, Wild Systems, and Santa Clara. 2012. Par4All — Open Source Parallelization for Heterogeneous Computing.

Potluri, S., H. Wang, D. Bureddy, a.K. Singh, C. Rosales, and Dhabaleswar K. Panda. 2012. “Optimizing MPI Communication on Multi-GPU Systems Using CUDA Inter-Process Communication.” 2012 IEEE 26th International Parallel and Distributed Processing Symposium Workshops & PhD Forum, May, 1848–57. https://doi.org/10.1109/IPDPSW.2012.228.

Pouchet, L. N. 2012. “PolyBench: The Polyhedral Benchmark Suite.” In URL: Http://Www. Cs. Ucla. Edu/~ Pouchet/Software/Polybench/[cited July,].

Pouchet, Louis-Noel, Cédric Bastoul, and Uday Bondhugula. n.d.-a. PoCC: The Polyhedral Compiler Collection, 2010.

Pouchet, Louis-Noel, Cédric Bastoul, and Uday Bondhugula. n.d.-b. PoCC: The Polyhedral Compiler Collection, 2010.

Pouchet, Louis-Noël, Uday Bondugula, and Tomofumi Yuki. 2012. PolyBench/C the Polyhedral Benchmark suite. http://web.cse.ohio-state.edu/~pouchet/software/polybench/.

Prema, S., R. Jehadeesan, B. K. Panigrahi, and S. A. V. Satya Murty. 2015. “Dependency Analysis and Loop Transformation Characteristics of Auto-Parallelizers.” 2015 National Conference on Parallel Computing Technologies (PARCOMPTECH), February, 1–6. https://doi.org/10.1109/PARCOMPTECH.2015.7084524.

Presented, A Thesis Proposal. 2012. Dynamic Translation of Runtime Environments for Heterogeneous Computing. no. April.

Processors, Graphics. 2010. CUDA Advanced Features. 1–11.

Programação Progressiva. 2019. Threads Em c – Como Programar Usando Pthreads. https://www.programacaoprogressiva.net/2019/02/Threads-em-C-Como-Programar-Usando-Pthreads.html.

Programming, Data Flow. 2011. The x-k. no. November.

Project, H P C, and C O M Bretagne. 2010. Par4All — Automatic Parallelization for CPU & GPU.

Project, HPC. 2012. Par4All — P4a Simple Command Line Interface. 1–35.

PROJECT, THE hiCUDA. 2012. “The hiCUDA Project Site @ONLINE.” http://www.eecg.utoronto.ca/~tsa/hicuda/.

PyCUDA, Site. 2012. “PyCUDA Site @ONLINE.” June. http://documen.tician.de/pycuda/.

Qadeer, Shaz, and Dinghao Wu. 2004. “KISS: Keep It Simple and Sequential.” SIGPLAN Not. (New York, NY, USA), PLDI ’04, vol. 39: 14–24. https://doi.org/10.1145/996841.996845.

Quint, Fernando Magno. n.d.-a. Code Optimization Techniques for Graphics Processing Units.

Quint, Fernando Magno. n.d.-b. Técnicas de Otimização de código Para Placas de Processamento Gráfico. 1–72.

Rajopadhye, S. 2007. The z -Polyhedral Model ∗. 237–48.

Region, Repeatable Simulation. 2013. Deterministic PinPoints:

Report, Openmp Technical, and Attached Accelerators. 2013. OpenMP Technical Report 1 on Directives for Attached Accelerators.

Resch, Michael M., Wolfgang Bez, Erich Focht, Hiroaki Kobayashi, and Nisarg Patel, eds. 2015. Sustained Simulation Performance 2014. Springer International Publishing. https://doi.org/10.1007/978-3-319-10626-7.

Reyes, Ruym’n, Iv’n Lopez, Juan J. Fumero, and Francisco de Sande. 2012. “accULL: An User-Directed Approach to Heterogeneous Programming.” 2012 IEEE 10th International Symposium on Parallel and Distributed Processing with Applications, July, 654–61. https://doi.org/10.1109/ISPA.2012.97.

Reyes, Ruym’n, Ivan Lopez, Juan J. Fumero, and Francisco de Sande. 2012. “Directive-Based Programming for GPUs: A Comparative Study.” 2012 IEEE 14th International Conference on High Performance Computing and Communication & 2012 IEEE 9th International Conference on Embedded Software and Systems, June, 410–17. https://doi.org/10.1109/HPCC.2012.62.

Reyes, Ruym$#225;n, Iv$#225;n López-Rodrı́guez, Juan J. Fumero, and Francisco de Sande. 2012. “accULL: An OpenACC Implementation with CUDA and OpenCL Support.” Proceedings of the 18th International Conference on Parallel Processing (Berlin, Heidelberg), Euro-par’12, 871–82. https://doi.org/10.1007/978-3-642-32820-6\_86.

Reyes, Ruymán, Iván López-Rodríguez, Juan J. Fumero, and Francisco de Sande. 2012. “accULL: An OpenACC Implementation with CUDA and OpenCL Support.” In Proceedings of the 18th International Conference on Parallel Processing (Euro-Par 2012), edited by Christos Kaklamanis, Theodore Papatheodorou, and Paul G. Spirakis, vol. 7484. Lecture Notes in Computer Science. Springer-Verlag. https://doi.org/10.1007/978-3-642-32820-6_86.

Reyes, Ruyman, and Francisco de Sande. 2011a. “Automatic Code Generation for GPUs in Llc.” The Journal of Supercomputing 58 (3): 349–56. https://doi.org/10.1007/s11227-011-0591-7.

Reyes, Ruyman, and Francisco de Sande. 2011b. “Optimize or Wait? Using Llc Fast-Prototyping Tool to Evaluate CUDA Optimizations.” 2011 19th International Euromicro Conference on Parallel, Distributed and Network-Based Processing, February, 257–61. https://doi.org/10.1109/PDP.2011.12.

Reyes, Ruymán, and Francisco de Sande. 2012. “Optimization Strategies in Different CUDA Architectures Using llCoMP.” Microprocessors and Microsystems 36 (2): 78–87. https://doi.org/10.1016/j.micpro.2011.05.006.

Rhodin, Helge. n.d. A PTX Code Generator for LLVM.

Robert, Y, and SW Song. 1992. “Revisiting Cycle Shrinking.” Parallel Computing, no. 88. http://www.sciencedirect.com/science/article/pii/016781919290084K.

Rohou, Erven, Sergei Dyshel, Dorit Nuzman, et al. 2011a. “Speculatively Vectorized Bytecode.” Proceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers - HiPEAC ’11 (New York, New York, USA), HiPEAC ’11, January, 35. https://doi.org/10.1145/1944862.1944871.

Rohou, Erven, Sergei Dyshel, Dorit Nuzman, et al. 2011b. “Speculatively Vectorized Bytecode.” Proceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers (New York, NY, USA), HiPEAC ’11, 35–44. https://doi.org/10.1145/1944862.1944871.

Rudy, Gabe, and Computer Science. 2010. CUDA-CHiLL: A PROGRAMMING LANGUAGE INTERFACE FOR GPGPU OPTIMIZATIONS AND CODE GENERATION. no. August.

Ruetsch, Greg, and Brent Oster. 2008. Getting Started with CUDA.

Runtime, Equipe, Inria Bordeaux Sud-ouest, and Introduction Les. 2009. Super-Lin´ Eaires. 7–14.

Ryoo, Shane, Christopher I. Rodrigues, Sara S. Baghsorkhi, Sam S. Stone, David B. Kirk, and Wen-mei W. Hwu. 2008. “Optimization Principles and Application Performance Evaluation of a Multithreaded GPU Using CUDA.” Proceedings of the 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming - PPoPP ’08 (New York, New York, USA), 73. https://doi.org/10.1145/1345206.1345220.

S. Beck, a.C., and L. Carro. 2005. “Dynamic Reconfiguration with Binary Translation: Breaking the ILP Barrier with Software Compatibility.” Proceedings. 42nd Design Automation Conference, 2005., 732–37. https://doi.org/10.1109/DAC.2005.193908.

Saillard, Emmanuelle, Patrick Carribault, and Denis Barthou. 2014. “Static Validation of Barriers and Worksharing Constructs in OpenMP Applications.” In Using and Improving OpenMP for Devices, Tasks, and More, edited by Luiz DeRose, BronisR. de Supinski, StephenL. Olivier, BarbaraM. Chapman, and MatthiasS. Müller, vol. 8766. Lecture Notes in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-11454-5{\_}6.

Sajjapongse, Kittisak, Xiang Wang, and Michela Becchi. 2013. “A Preemption-Based Runtime to Efficiently Schedule Multi-Process Applications on Heterogeneous Clusters with GPUs.” Proceedings of the 22nd International Symposium on High-Performance Parallel and Distributed Computing - HPDC ’13 (New York, New York, USA), June, 179. https://doi.org/10.1145/2493123.2462911.

Sands, Duncan, and Deep Blue Capital. n.d. Reimplementing Llvm-Gcc as a Gcc Plugin.

Satish, Nadathur, Computer Sciences, Mark Harris, Michael Garland, and Santa Clara. 2009. Designing Efficient Sorting Algorithms for Manycore GPUs. no. May: 1–10.

Schaa, Dana, and David Kaeli. 2011. Caracal: Dynamic Translation of Runtime Environments for GPUs. no. March.

Scheduling, Task. n.d. Parallel Task Scheduling for the Block Data Flow Architecture *. 1.

Schroeder, Tim C. 2011a. Peer-to-Peer & Unified Virtual Addressing.

Schroeder, Tim C. 2011b. “Peer-to-Peer and Unified Virtual Addressing.” Cuda Webinar.

Science, Computational. 2012. A Simple Tutorial on Generating PTX Assembler Out of Ada Source Code Using LLVM NVPTX Backend. 1–32.

Science, Computational. 2014. Evaluating Manual and Compiler-Driven Parallelization of Stencil Micro-Applications on a GPU-Enabled Cluster. 1–34.

Science, Computer. 2011. The Polyhedral Compilation Framework.

Sclocco, Alessio, Henri E. Bal, Jason Hessels, Joeri van Leeuwen, and Rob V. van Nieuwpoort. 2014. “Auto-Tuning Dedispersion for Many-Core Accelerators.” 2014 IEEE 28th International Parallel and Distributed Processing Symposium, May, 952–61. https://doi.org/10.1109/IPDPS.2014.101.

Sena, M C R, J A C Costa, C A Thomaz, et al. 2008. Tutorial de OpenMP c/c++. 03/2008. Edition 1. LCCV-UFAL. http://www.lncc.br/pdf{\_}consultar.php?idt{\_}arquivo=4286.

Shah, Sanjiv, Grant Haab, Paul Petersen, and Joe Throop. 2000. “Flexible Control Structures for Parallelism in OpenMP.” Concurrency: Practice and Experience 12 (12): 1219–39. https://doi.org/10.1002/1096-9128(200010)12:12<1219::AID-CPE530>3.0.CO;2-0.

Sharp, Oliver J. 1994. Compiler Transformations. 26 (4).

Shi, Huihui, Yi Wang, Haibing Guan, and Alei Liang. 2007. “An Intermediate Language Level Optimization Framework for Dynamic Binary Translation.” ACM SIGPLAN Notices 42 (5): 3–9. https://doi.org/10.1145/1286341.1286342.

Shi, Lin, Hao Chen, and Ting Li. 2014. “Hybrid CPU/GPU Checkpoint for GPU-Based Heterogeneous Systems.” In Parallel Computational Fluid Dynamics, edited by Kenli Li, Zheng Xiao, Yan Wang, Jiayi Du, and Keqin Li, vol. 405. Communications in Computer and Information Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-53962-6{\_}42.

Sidelnik, Albert. n.d. Targeting GPUs and Other Hierarchical Architectures in Chapel. 1–20.

Sidelnik, Albert, Saeed Maleki, Bradford L. Chamberlain, Maria J. Garzar’n, and David Padua. 2012. “Performance Portability with the Chapel Language.” 2012 IEEE 26th International Parallel and Distributed Processing Symposium, May, 582–94. https://doi.org/10.1109/IPDPS.2012.60.

Siegl, Patrick, Rainer Buchty, and Mladen Berekovic. 2015. “Revealing Potential Performance Improvements by Utilizing Hybrid Work-Sharing for Resource-Intensive Seismic Applications.” 2015 23rd Euromicro International Conference on Parallel, Distributed, and Network-Based Processing, March, 659–63. https://doi.org/10.1109/PDP.2015.28.

Silberschatz, Abraham, Peter Baer Galvin, and Greg Gagne. 2015. Fundamentos de Sistemas Operacionais. 9th ed. LTC.

Simbürger, A, and Sven Apel. 2013. “The Potential of Polyhedral Optimization.” …, no. February. http://www.infosun.fim.uni-passau.de/publications/docs/SAGL13tr.pdf.

Sjödin, Jan, Sebastian Pop, Harsha Jagasia, Tobias Grosser, and Antoniu Pop. 2009. “Design of graphite and the Polyhedral Compilation Package.” GCC Developers’ Summit (Montréal, Canada), June. https://hal-mines-paristech.archives-ouvertes.fr/hal-00408759.

Smith, J. E., and G. S. Sohi. 1995. “The Microarchitecture of Superscalar Processors.” Proceedings of the IEEE 83 (12): 1609–24. https://doi.org/10.1109/5.476078.

Sondak, Doug. 2011. “Parallel Processing with OpenMP.” Scientific Computing; Visualization Office of Information Technology, Boston University. www.bu.edu/tech/files/2011/09/openmp.ppt.

Spampinato, Norwegian Daniele G, Anne C Elster, and Thorvald Natvig. n.d. Modelling Multi-GPU Systems 1.

Specification, A, Polyhedral Representation Extractor, High Level, and Programs Edition. 2014. Cédric Bastoul. http://icps.u-strasbg.fr/~bastoul/development/clan/docs/clan.pdf.

Specification, Streamc Language. 2000. 1.0 StreamC Language Specification. 3–8.

Speyer, G, N Freed, R Akis, D Stanzione, and E Mack. 2008. “Paradigms for Parallel Computation.” DoD HPCMP Users Group Conference, 2008. DOD HPCMP UGC, 486–94. https://doi.org/10.1109/DoD.HPCMP.UGC.2008.18.

Spracklen, Lawrence, and Santosh G. Abraham. 2005. “Chip Multithreading: Opportunities and Challenges.” Proceedings of the 11th International Symposium on High-Performance Computer Architecture (USA), HPCA ’05, 248–52. https://doi.org/10.1109/HPCA.2005.10.

STALLINGS, William. 2002. Arquitetura e Organização de Computadores: Projeto Para o Desempenho. 5th ed. Prentice-Hall.

Stallman, Richard M, G C C Developer, and Community Last. 2004. GNU Compiler Collection Internals. no. May.

Standard, OpenACC. 2012. “OpenACC Directives for Accelerators Site @ONLINE.” March. http://www.openacc-standard.org/.

Stock, Kevin. n.d. Automatic Transformations for Effective Parallel Execution on Intel Many Integrated Core. 1–6.

Stratton, John A, Christopher Rodrigues, I-jui Sung, et al. 2012. Parboil: A Revised Benchmark Suite for Scientific and Commercial Throughput Computing.

Strazdins, P E. 2012. “Experiences in Teaching a Specialty Multicore Computing Course.” Parallel and Distributed Processing Symposium Workshops PhD Forum (IPDPSW), 2012 IEEE 26th International, 1283–88. https://doi.org/10.1109/IPDPSW.2012.168.

Stuart, Jeff A, Michael Cox, and John D Owens. n.d. GPU-to-CPU Callbacks.

Submitted, Dissertation, and Computer Science. 2005. Macroscopic Data Structure Analysis and Optimization.

Sukumaran-Rajam, Aravind, Juan Manuel Martinez, Willy Wolff, Alexandra Jimborean, and Philippe Clauss. 2014. “Speculative Program Parallelization with Scalable and Decentralized Runtime Verification.” In Runtime Verification, edited by Borzoo Bonakdarpour and Scott A. Smolka, vol. 8734. Springer. https://doi.org/10.1007/978-3-319-11164-3\_11.

Sumner, Nick. 2013. A Brief Introduction to Using LLVM.

Süß, Michael, and Claudia Leopold. 2005. “Common Mistakes in OpenMP and How to Avoid Them: A Collection of Best Practices.” Proceedings of the 2005 and 2006 International Conference on OpenMP Shared Memory Parallel Programming (Berlin, Heidelberg), IWOMP’05/IWOMP’06, June, 312–23. http://dl.acm.org/citation.cfm?id=1892830.1892863.

Süß, Michael, and Claudia Leopold. 2010. “A User’s Experience with Parallel Sorting and Openmp.” In Proceedings of the Sixth Workshop on OpenMP (EWOMP’04.

Sutter, Herb. 2005. “The Free Lunch Is over: A Fundamental Turn Toward Concurrency in Software.” Dr. Dobb’s Journal 30 (3): 202–10. http://www.gotw.ca/publications/concurrency-ddj.htm.

Sutter, Herb, and James Larus. 2005. “Software and the Concurrency Revolution.” Queue (New York, NY, USA) 3 (7): 54–62. https://doi.org/10.1145/1095408.1095421.

Synthesis, Automatic Architecture, and Application Mapping. 2011. Automatic Architecture Synthesis and Application Mapping D3.1: Method of and Report on Application Analysis/Profiling and Parallelization. no. 100265: 1–98.

Takeshima, R, and T Tsumura. 2014. “Automatic Code Tuning for Improving GPU Resource Utilization.” Computing and Networking (CANDAR), 2014 Second International Symposium on, 419–25. https://doi.org/10.1109/CANDAR.2014.48.

Takizawa, Hiroyuki, Katsuto Sato, Kazuhiko Komatsu, and Hiroaki Kobayashi. 2009. “CheCUDA: A Checkpoint/Restart Tool for CUDA Applications.” 2009 International Conference on Parallel and Distributed Computing, Applications and Technologies, December, 408–13. https://doi.org/10.1109/PDCAT.2009.78.

Tanasic, Ivan, Isaac Gelado, Javier Cabezas, Alex Ramirez, Nacho Navarro, and Mateo Valero. 2014. “Enabling Preemptive Multiprogramming on GPUs.” 2014 ACM/IEEE 41st International Symposium on Computer Architecture (ISCA), June, 193–204. https://doi.org/10.1109/ISCA.2014.6853208.

Tanenbaum, Andrew S., and Herbert Bos. 2016. Sistemas Operacionais Modernos. 4th ed. Pearson Education do Brasil.

Tang, Tao, Xuejun Yang, and Yisong Lin. 2011. “Cache Miss Analysis for GPU Programs Based on Stack Distance Profile.” 2011 31st International Conference on Distributed Computing Systems, June, 623–34. https://doi.org/10.1109/ICDCS.2011.16.

Taura, Kenjiro. n.d. Programming in Chapel.

Team, The Mendeley Support. 2011. Getting Started with Mendeley. Mendeley Ltd. http://www.mendeley.com.

Tenerife, Santa Cruz De. n.d. OpenACC Implementations Comparison.

The Open Group. 2018. POSIX Threads Programming. https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_create.html.

Tomasoni, Johannes, Sergei Gorlatch, and Christian Lengauer. n.d. Loopo-Hoc: A Grid Component with Embedded Loop Parallelization.

Tomasulo, R. M. 1967a. “An Efficient Algorithm for Exploiting Multiple Arithmetic Units.” IBM Journal of Research and Development 11 (1): 25–33. https://doi.org/10.1147/rd.111.0025.

Tomasulo, R. M. 1967b. “An Efficient Algorithm for Exploiting Multiple Arithmetic Units.” IBM Journal of Research and Development 11 (1): 25–33. https://doi.org/10.1147/rd.111.0025.

Tong, Xin, and Andreas Moshovos. 2015. “QTrace: A Framework for Customizable Full System Instrumentation.” 2015 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), March, 245–55. https://doi.org/10.1109/ISPASS.2015.7095810.

TOP500. 2013, 2014. “TOP500 Supercomputers Sites @ONLINE.” 2013, 2014. http://www.top500.org/.

Top500. 2013. TOP500 List of Supercomputers Site. http://www.top500.org/.

Top500. 2014. TOP500 List of Supercomputers Site. http://www.top500.org/.

Top500. 2015. TOP500 List of Supercomputers Site. http://www.top500.org/.

Top500. 2016. TOP500 List of Supercomputers Site. http://www.top500.org/.

Trahay, François, François Rue, Mathieu Faverge, Yutaka Ishikawa, Raymond Namyst, and Jack Dongarra. 2011. “EZTrace: a generic framework for performance analysis.” IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGrid) (Newport Beach, CA, United States), May. https://hal.inria.fr/inria-00587216.

Transformations, Loop. n.d. Loop Transformations for Parallelism & Locality. 1–6.

Triolet, Rémi, Francois Irigoin, and Paul Feautrier. 1986a. “Direct Parallelization of Call Statements.” Proceedings of the 1986 SIGPLAN Symposium on Compiler Construction (New York, NY, USA), SIGPLAN ’86, 176–85. https://doi.org/10.1145/12276.13329.

Triolet, Rémi, Francois Irigoin, and Paul Feautrier. 1986c. “Direct Parallelization of Call Statements.” SIGPLAN Not. (New York, NY, USA) 21 (7): 176–85. https://doi.org/10.1145/13310.13329.

Triolet, Rémi, Francois Irigoin, and Paul Feautrier. 1986b. “Direct Parallelization of Call Statements.” SIGPLAN Not. (New York, NY, USA) 21 (7): 176–85. https://doi.org/10.1145/13310.13329.

Tullsen, Dean M., Susan J. Eggers, and Henry M. Levy. 1995b. “Simultaneous Multithreading: Maximizing on-Chip Parallelism.” Proceedings of the 22Nd Annual International Symposium on Computer Architecture (New York, NY, USA), ISCA ’95, 392–403. https://doi.org/10.1145/223982.224449.

Tullsen, Dean M., Susan J. Eggers, and Henry M. Levy. 1995a. “Simultaneous Multithreading: Maximizing on-Chip Parallelism.” Proceedings of the 22nd Annual International Symposium on Computer Architecture (New York, NY, USA), ISCA ’95, 392–403. https://doi.org/10.1145/223982.224449.

Tullsen, Dean M., Susan J. Eggers, and Henry M. Levy. 1995d. “Simultaneous Multithreading: Maximizing on-Chip Parallelism.” SIGARCH Comput. Archit. News (New York, NY, USA) 23 (2): 392–403. https://doi.org/10.1145/225830.224449.

Tullsen, Dean M., Susan J. Eggers, and Henry M. Levy. 1995c. “Simultaneous Multithreading: Maximizing on-Chip Parallelism.” SIGARCH Comput. Archit. News (New York, NY, USA) 23 (2): 392–403. https://doi.org/10.1145/225830.224449.

Ujaldon, Manuel. n.d. Inside Kepler.

Upgrade, Why. n.d. Why Upgrade? 1–2.

Valiant, Leslie G. n.d. A Bridging Model for Multi-Core Computing. 5193: 13–28.

Vancourt, Tom. n.d. Research Program: FPGAs as Computation Accelerators. 3–5.

Ventroux, N, T Sassolas, A Guerre, B Creusillet, and R Keryell. 2012. SESAM/Par4All: A Tool for Joint Exploration of MPSoC Architectures and Dynamic Dataflow Code Generation. 0–7.

Verdoolaege, Sven. 2010a. “Isl: An Integer Set Library for the Polyhedral Model.” In Mathematical Software ? ICMS 2010, edited by Komei Fukuda, Jorisvander Hoeven, Michael Joswig, and Nobuki Takayama, vol. 6327. Lecture Notes in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15582-6_49.

Verdoolaege, Sven. 2010b. “isl: An Integer Set Library for the Polyhedral Model.” In Proceedings of the Third International Congress Conference on Mathematical Software - ICMS 2010, edited by Komei Fukuda, Jorisvander Hoeven, Michael Joswig, and Nobuki Takayama, vol. 6327. ICMS’10. Springer-Verlag. https://doi.org/10.1007/978-3-642-15582-6_49.

Verdoolaege, Sven. 2010c. “Isl: An Integer Set Library for the Polyhedral Model.” Proceedings of the Third International Congress Conference on Mathematical Software (Berlin, Heidelberg), ICMS’10, 299–302. http://dl.acm.org/citation.cfm?id=1888390.1888455.

Verdoolaege, Sven, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. 2013. “Polyhedral Parallel Code Generation for CUDA.” ACM Trans. Archit. Code Optim. (New York, NY, USA) 9 (4): 54:1–23. https://doi.org/10.1145/2400682.2400713.

Verdoolaege, Sven, and Tobias Grosser. 2012c. “Polyhedral Extraction Tool.” Second Int. Workshop on Polyhedral Compilation Techniques (IMPACT’12) (Paris, France), January.

Verdoolaege, Sven, and Tobias Grosser. 2012b. “Polyhedral Extraction Tool.” Second Int. Workshop on Polyhedral Compilation Techniques (IMPACT’12) (Paris, France), January.

Verdoolaege, Sven, and Tobias Grosser. 2012a. “Polyhedral Extraction Tool.” Second Int. Workshop on Polyhedral Compilation Techniques (IMPACT’12) (Paris, France), January.

Verdoolaege, Sven, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. 2013b. “Polyhedral Parallel Code Generation for CUDA.” ACM Trans. Archit. Code Optim. (New York, NY, USA) 9 (4): 54:1–23. https://doi.org/10.1145/2400682.2400713.

Verdoolaege, Sven, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. 2013a. “Polyhedral Parallel Code Generation for CUDA.” ACM Trans. Archit. Code Optim. (New York, NY, USA) 9 (4): 54:1–23. https://doi.org/10.1145/2400682.2400713.

Volkov, V., and J. W. Demmel. 2008. “Benchmarking GPUs to Tune Dense Linear Algebra.” 2008 SC - International Conference for High Performance Computing, Networking, Storage and Analysis, November, 1–11. https://doi.org/10.1109/SC.2008.5214359.

Wang, Jin, and Sudhakar Yalamanchili. 2014. “Characterization and Analysis of Dynamic Parallelism in Unstructured GPU Applications.” 2014 IEEE International Symposium on Workload Characterization (IISWC), October, 51–60. https://doi.org/10.1109/IISWC.2014.6983039.

Wang, Lingyuan, Miaoqing Huang, and T. El-Ghazawi. 2011. “Exploiting Concurrent Kernel Execution on Graphic Processing Units.” High Performance Computing and Simulation (HPCS), 2011 International Conference on, 24–32. https://doi.org/10.1109/HPCSim.2011.5999803.

Wang, Xun, Degui Feng, Chen Tian-zhou, and Hu Tong-sen. 2012. “Migration Between Software and Hardware Task on Preemptive Multitasking CPU/FPGA Hybrid Architecture.” 2012 IEEE 14th International Conference on High Performance Computing and Communication & 2012 IEEE 9th International Conference on Embedded Software and Systems, June, 1329–36. https://doi.org/10.1109/HPCC.2012.196.

Weaver, Vincent M. 2015. “Self-Monitoring Overhead of the Linux Perf_ Event Performance Counter Interface.” 2015 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), March, 102–11. https://doi.org/10.1109/ISPASS.2015.7095789.

Weaver, Vincent M., Matt Johnson, Kiran Kasichayanula, et al. 2012. “Measuring Energy and Power with PAPI.” 2012 41st International Conference on Parallel Processing Workshops, no. May (September): 262–68. https://doi.org/10.1109/ICPPW.2012.39.

Weaver, Vincent M., Dan Terpstra, Heike McCraw, et al. 2013. “PAPI 5: Measuring Power, Energy, and the Cloud.” 2013 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), April, 124–25. https://doi.org/10.1109/ISPASS.2013.6557155.

Werkhoven, B. van, J. Maassen, F. J. Seinstra, and H. E. Bal. 2014. “Performance Models for CPU-GPU Data Transfers.” 2014 14th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing, May, 11–20. https://doi.org/10.1109/CCGrid.2014.16.

Werkhoven, Ben van, Jason Maassen, Henri E. Bal, and Frank J. Seinstra. 2014. “Optimizing Convolution Operations on GPUs Using Adaptive Tiling.” Future Generation Computer Systems 30 (January): 14–26. https://doi.org/10.1016/j.future.2013.09.003.

Wienke, Sandra, Paul Springer, Christian Terboven, and Dieter Mey. 2012. LNCS 7484 - OpenACC — First Experiences with Real-World Applications. nos. November 2011: 859–70.

Williams, Samuel Webb, Andrew Waterman, and David A. Patterson. 2008. Roofline: An Insightful Visual Performance Model for Floating-Point Programs and Multicore Architectures. UCB/EECS-2008-134. EECS Department, University of California, Berkeley. http://www.eecs.berkeley.edu/Pubs/TechRpts/2008/EECS-2008-134.html.

Williams, Samuel, Andrew Waterman, and David Patterson. 2009. “Roofline: An Insightful Visual Performance Model for Multicore Architectures.” Communications of the ACM 52 (4): 65. https://doi.org/10.1145/1498765.1498785.

Wolfe, Michael. 1996. “Parallelizing Compilers.” ACM Comput. Surv. (New York, NY, USA) 28 (1): 261–62. https://doi.org/10.1145/234313.234417.

Xu, Cheng-Zhong. 2004. “ECE561:introduction to Parallel and Distribution Systems. OpenMP Overview.” http://www.ece.eng.wayne.edu/{~}czxu/ece561/lnotes/OpenMP.pdf.

Yamamoto, W., M. J. Serrano, A. R. Talcott, R. C. Wood, and M. Nemirosky. 1994. “Performance Estimation of Multistreamed, Superscalar Processors.” 1994 Proceedings of the Twenty-Seventh Hawaii International Conference on System Sciences 1: 195–204. https://doi.org/10.1109/HICSS.1994.323172.

Yan, Yonghong, Max Grossman, and Vivek Sarkar. 2009. “JCUDA: A Programmer-Friendly Interface for Accelerating Java Programs with CUDA.” Proceedings of the 15th International Euro-Par Conference on Parallel Processing (Berlin, Heidelberg), Euro-par ’09, 887–99. https://doi.org/10.1007/978-3-642-03869-3_82.