3 ms·

Plus vendor compilers often outperform GCC and LLVM… on Cray systems especially

• sanderjd 3y ago
  Can Julia take advantage of that?
  • pjmlp 3y ago
    Cray is pushing their own language as well, Chapel. https://chapel-lang.org/ https://chapel-lang.org/ As for Julia on Cray, "Julia — The Newest Petaflop Family Language We Have Started to Love" https://www.avenga.com/magazine/julia-programming-language https://www.avenga.com/magazine/julia-programming-language > Julia is one of the few languages that are in the so-called PetaFlop family; the other languages are C, C++ and Fortrant. It achieved 1.54 petaflops with 1.3 million threads on the Cray XC40 supercomputer.
    • sanderjd 3y ago
      But specifically because of the proprietary compiler? Or is it just calling Fortran / C / C++ libraries that were compiled with their compiler?
      • leephillips 3y ago
        The program is Celeste: https://juliahub.com/case-studies/celeste/index.html https://juliahub.com/case-studies/celeste/index.html It seems to be pure Julia. Julia uses the LLVM compiler; I’m pretty sure that’s the only platform, aside from experiments compiling to WASM.
      • DNF2 3y ago
        The compiler is free and open source, not proprietary. It is built on LLVM, which is also FOSS. And Julia code is not Fortran/C/C++, not sure what you are asking.
        • sanderjd 3y ago
          The comment I replied to said: "Plus vendor compilers often outperform GCC and LLVM… on Cray systems especially". I said "Can Julia take advantage of that?". So the "that" in my question was "vendor compilers [which] often outperform GCC and LLVM... on Cray systems especially". It seems like the answer is, no, Julia cannot be compiled with those vendor compilers that often outperform LLVM. But it seems that Julia nonetheless has been shown to perform well, just not specifically by using those vendor compilers that I was asking about.
      • bradcray 3y ago
        My understanding is that the Julia Petaflops run executed a Julia program per node, communicating via MPI. For some, that's probably obvious/expected for HPC; for others, it might not be considered "pure Julia".
        • cbkeller 3y ago
          That's how it works in any language on a supercomputer. MPI is pretty much the only game in town for inter-node communication.
          • bradcray 3y ago
            @cbkeller: Though MPI is dominant in HPC by a very large margin, it's definitely not the only game in town. SHMEM is an MPI alternative with a smaller but very dedicated following. UPC, Fortran 2008, UPC++, and Chapel are all alternatives that support inter-node communication without relying on MPI or explicit library communication calls. Chapel has the additional advantage of not imposing the SPMD programming model on the user and supporting asynchronous dynamic tasking. It's my understanding that Julia aspires to join this group of languages if it is able to do so, which is why the Petaflops announcement was originally enticing to me, and then became somewhat less so once I learned that it was relying on MPI.
  • physicsguy 3y ago
    In theory, but it’s usually specific optimisations that work well on HPC codes that they’d need to replicate at the LLVM level: https://www.umr-cnrm.fr/aladin/IMG/pdf/compilers_elsinore_rek.pdf https://www.umr-cnrm.fr/aladin/IMG/pdf/compilers_elsinore_re...
    • sanderjd 3y ago
      Awesome, thanks for the link!