Single Assignment C (SAC) - The Compilation Technology Perspective

Single Assignment C (SaC) is a data parallel programming language that combines an imperative looking syntax, closely resembling that of C, with purely functional, state-free semantics. Again unlike the functional programming mainstream, that puts the emphasis on lists and trees, the focus of SaC as a data-parallel language is on (truly) multi-dimensional arrays. SaC arrays are not just loose collections of data cells or memory address ranges as in many imperative and object-oriented languages. Neither are they explicitly managed, stateful data objects as in some functional languages, may it be for language design or for performance considerations. SaC arrays are indeed purely functional, immutable, state-free, first-class values.

[1]  Barbara Chapman,et al.  Using OpenMP - portable shared memory parallel programming , 2007, Scientific and engineering computation.

[2]  Clemens Grelck,et al.  SAC—A Functional Array Language for Efficient Multi-threaded Execution , 2006, International Journal of Parallel Programming.

[3]  Robert Bernecky,et al.  The role of APL and J in high-performance computation , 1993, APL '93.

[4]  Bradford L. Chamberlain,et al.  Parallel Programmability and the Chapel Language , 2007, Int. J. High Perform. Comput. Appl..

[5]  Guy E. Blelloch,et al.  Implementation of a portable nested data-parallel language , 1993, PPOPP '93.

[6]  Hans-Wolfgang Loidl,et al.  Algorithm + strategy = parallelism , 1998, Journal of Functional Programming.

[7]  Clemens Grelck,et al.  Towards Hybrid Array Types in SAC , 2014, Software Engineering.

[8]  Clemens Grelck.  Implementing the NAS benchmark MG in SAC , 2002, Proceedings 16th International Parallel and Distributed Processing Symposium.

[9]  David H. Bailey,et al.  The Nas Parallel Benchmarks , 1991, Int. J. High Perform. Comput. Appl..

[10]  Alexander V. Shafarenko,et al.  Index Vector Elimination - Making Index Vectors Affordable , 2006, IFL.

[11]  Clemens Grelck,et al.  Combining high productivity and high performance in image processing using Single Assignment C on multi-core CPUs and many-core GPUs , 2012, J. Electronic Imaging.

[12]  Clemens Grelck,et al.  Compiling the functional data-parallel language SaC for Microgrids of Self-Adaptive Virtual Processors , 2009 .

[13]  L. Dagum,et al.  OpenMP: an industry standard API for shared-memory programming , 1998 .

[14]  Alexander V. Shafarenko,et al.  Numerical Simulations of Unsteady Shock Wave Interactions Using SaC and Fortran-90 , 2009, PaCT.

[15]  Dawei Huang,et al.  A 40 nm 16-Core 128-Thread SPARC SoC Processor , 2011, IEEE Journal of Solid-State Circuits.

[16]  David C. Cann,et al.  Retire Fortran?: a debate rekindled , 1992, CACM.

[17]  M. A. Jenkins,et al.  Effective data parallel computation using the Psi calculus , 1996 .

[18]  Mohan J. Kumar.  Advanced Reliability for Intel ® Xeon ® Processor-based Servers With an array of new reliability, availability, and serviceability (RAS) features, the Intel® Xeon® processor 7500 series offers exceptional data integrity and resilience for mission-critical computing environments. , 2010 .

[19]  Clemens Grelck,et al.  With-Loop Fusion for Data Locality and Parallelism , 2005, IFL.

[20]  John H. G. van Groningen.  The Implementation and Efficiency of Arrays in Clean 1.1 , 1996, Implementation of Functional Languages.

[21]  Simon L. Peyton Jones,et al.  Data parallel Haskell: a status report , 2007, DAMP '07.

[22]  Sven-Bodo Scholz,et al.  A Case Study: Effects of WITH-Loop-Folding on the NAS Benchmark MG in SAC , 1998, IFL.

[23]  Clemens Grelck,et al.  Next Generation Asynchronous Adaptive Specialization for Data-Parallel Functional Array Processing in SAC: Accelerating the Availability of Specialized High Performance Code , 2013, IFL '13.

[24]  Clemens Grelck,et al.  Asynchronous adaptive optimisation for generic data‐parallel array programming , 2012, Concurr. Comput. Pract. Exp..

[25]  Clemens Grelck,et al.  SaC/C formulations of the all‐pairs N‐body problem and their performance on SMPs and GPGPUs , 2014, Concurr. Comput. Pract. Exp..

[26]  Clemens Grelck,et al.  With-Loop Scalarization - Merging Nested Array Operations , 2003, IFL.

[27]  Clemens Grelck,et al.  Efficient Heap Management for Declarative Data Parallel Programming on Multicores. , 2008 .

[28]  Chris R. Jesshope,et al.  On the Compilation of a Language for General Concurrent Target Architectures , 2010, Parallel Process. Lett..

[29]  Clemens Grelck.  A Multithreaded Compiler Backend for High-level Array Programming , 2003, Applied Informatics.

[30]  Clemens Grelck,et al.  Shared memory multiprocessor support for functional array processing in SAC , 2005, J. Funct. Program..

[31]  Kenneth E. Iverson,et al.  The Design of APL , 1973, IBM J. Res. Dev..

[32]  Calvin J. Ribbens,et al.  Is It Time to Rethink Distributed Shared Memory Systems? , 2011, 2011 IEEE 17th International Conference on Parallel and Distributed Systems.

[33]  Bruce A. Draper,et al.  Sassy: A Language and Optimizing Compiler for Image Processing on Reconfigurable Computing Systems , 1999, ICVS.

[34]  Clemens Grelck,et al.  Towards Heterogeneous Computing without Heterogeneous Programming , 2012, Trends in Functional Programming.

[35]  Alexander V. Shafarenko,et al.  Implementing a Numerical Solution of the KPI Equation Using Single Assignment C: Lessons and Experiences , 2005, IFL.

[36]  Brian Vinter,et al.  Numerical Python for scalable architectures , 2010, PGAS '10.

[37]  George Chrysos,et al.  Intel® Xeon Phi coprocessor (codename Knights Corner) , 2012, 2012 IEEE Hot Chips 24 Symposium (HCS).

[38]  Clemens Grelck,et al.  Single Assignment C (SAC) High Productivity Meets High Performance , 2011, CEFP.

[39]  Gaël Varoquaux,et al.  The NumPy Array: A Structure for Efficient Numerical Computation , 2011, Computing in Science & Engineering.

[40]  Alexander V. Shafarenko,et al.  Asynchronous Stream Processing with S-Net , 2010, International Journal of Parallel Programming.

[41]  Manuel M. T. Chakravarty,et al.  An Approach to Fast Arrays in Haskell , 2002, Advanced Functional Programming.

[42]  Clemens Grelck,et al.  Improving Cache Effectiveness through Array Data Layout Manipulation in SAC , 2000, IFL.

[43]  Simon L. Peyton Jones,et al.  Parallel generational-copying garbage collection with a block-structured heap , 2008, ISMM '08.

[44]  Clemens Grelck,et al.  Dependently typed array programs don't go wrong , 2009, J. Log. Algebraic Methods Program..

[45]  Kenneth E. Iverson,et al.  A programming language , 1899, AIEE-IRE '62 (Spring).

[46]  Clemens Grelck,et al.  Concurrent Non-deferred Reference Counting on the Microgrid: First Experiences , 2010, IFL.

[47]  M. A. Jenkins.  Q'Nial: A portable interpreter for the nested interactive array language, Nial , 1989, Softw. Pract. Exp..

[48]  Sven-Bodo Scholz,et al.  Single Assignment C: efficient support for high-level array operations in a functional setting , 2003, Journal of Functional Programming.

[49]  Clemens Grelck,et al.  SAC: off-the-shelf support for data-parallelism on multicores , 2007, DAMP '07.

[50]  Clemens Grelck,et al.  HPF vs. SAC - A Case Study (Research Note) , 2000, Euro-Par.

[51]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[52]  Clemens Grelck,et al.  On Code Generation for Multi-generator WITH-Loops in SAC , 1999, IFL.

[53]  Bruce A. Draper,et al.  High-Level Language Abstraction for Reconfigurable Computing , 2003, Computer.

[54]  Chris R. Jesshope,et al.  Implementation and evaluation of a microthread architecture , 2009, J. Syst. Archit..

[55]  Clemens Grelck,et al.  Towards an Efficient Functional Implementation of the NAS Benchmark FT , 2003, PaCT.

[56]  Clemens Grelck,et al.  SAC on a Niagara T3-4 Server: Lessons and Experiences , 2011, PARCO.

[57]  William Gropp,et al.  Skjellum using mpi: portable parallel programming with the message-passing interface , 1994 .

[58]  Clemens Grelck,et al.  Implicit Memory Management for SAC. , 2004 .

[59]  Sven-Bodo Scholz,et al.  Breaking the GPU programming barrier with the auto-parallelising SAC compiler , 2011, DAMP '11.

[60]  George E. Collins,et al.  A method for overlapping and erasure of lists , 1960, CACM.

[61]  James Reinders,et al.  Intel Xeon Phi Coprocessor High Performance Programming , 2013 .

[62]  M. A. Jenkins,et al.  A Comparison of Array Theory and a Mathematics of Arrays , 1991 .

[63]  Paul Hudak,et al.  The aggregate update problem in functional programming systems , 1985, POPL.

[64]  Simon L. Peyton Jones,et al.  Harnessing the Multicores: Nested Data Parallelism in Haskell , 2008, FSTTCS.

[65]  John Glauert,et al.  SISAL: streams and iteration in a single assignment language. Language reference manual, Version 1. 2. Revision 1 , 1985 .

[66]  Sven-Bodo Scholz,et al.  WITH-Loop-Folding in SAC - Condensing Consecutive Array Operations , 1997, Implementation of Functional Languages.

[67]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .