From 7c3fc31a167c1c1029894b90d9fe0c2d7bb40387 Mon Sep 17 00:00:00 2001 From: utkinis Date: Tue, 15 Oct 2024 17:13:43 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20=20@=2092d58?= =?UTF-8?q?c83f979683c8fd271eef04b2db976496eb7=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 404.html | 2 +- Manifest.toml | 4 +- assets/literate/l5_1-cpu-parallel_web.md | 85 +++++++++++-------- .../literate/l5_1-cpu-parallel_web_script.jl | 83 ++++++++++-------- extras/index.html | 2 +- final_proj/index.html | 2 +- homework/index.html | 2 +- index.html | 2 +- lecture1/index.html | 2 +- lecture10/index.html | 2 +- lecture2/index.html | 2 +- lecture3/index.html | 2 +- lecture4/index.html | 2 +- lecture5/index.html | 85 +++++++++++-------- lecture6/index.html | 2 +- lecture7/index.html | 2 +- lecture8/index.html | 2 +- lecture9/index.html | 2 +- logistics/index.html | 2 +- package-lock.json | 22 ++--- search/index.html | 2 +- sitemap.xml | 34 ++++---- software_install/index.html | 2 +- 23 files changed, 196 insertions(+), 151 deletions(-) diff --git a/404.html b/404.html index 6fa030e3..bc20d3d5 100644 --- a/404.html +++ b/404.html @@ -1 +1 @@ - 404: File not found
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



404: File not found

The requested file was not found.

Please click here to go to the home page.

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + 404: File not found
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



404: File not found

The requested file was not found.

Please click here to go to the home page.

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/Manifest.toml b/Manifest.toml index 7cd9e6ab..95b0790f 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -101,9 +101,9 @@ version = "1.11.0" [[deps.JLLWrappers]] deps = ["Artifacts", "Preferences"] -git-tree-sha1 = "f389674c99bfcde17dc57454011aa44d5a260a40" +git-tree-sha1 = "be3dc50a92e5a386872a493a10050136d4703f9b" uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" -version = "1.6.0" +version = "1.6.1" [[deps.JSON]] deps = ["Dates", "Mmap", "Parsers", "Unicode"] diff --git a/assets/literate/l5_1-cpu-parallel_web.md b/assets/literate/l5_1-cpu-parallel_web.md index a15c12cb..f19561ed 100644 --- a/assets/literate/l5_1-cpu-parallel_web.md +++ b/assets/literate/l5_1-cpu-parallel_web.md @@ -145,17 +145,17 @@ As first task, we'll compute the $T_\mathrm{eff}$ for the 2D fluid pressure (dif - Compute the elapsed time `t_toc` at the end of the time loop and report: ````julia:ex1 -t_toc = ... -A_eff = ... # Effective main memory access per iteration [GB] -t_it = ... # Execution time per iteration [s] -T_eff = A_eff/t_it # Effective memory throughput [GB/s] +t_toc = Base.time() - t_tic +A_eff = (3*2)/1e9*nx*ny*sizeof(Float64) # Effective main memory access per iteration [GB] +t_it = t_toc/niter # Execution time per iteration [s] +T_eff = A_eff/t_it # Effective memory throughput [GB/s] ```` - Report `t_toc`, `T_eff` and `niter` at the end of the code, formatting output using `@printf()` macro. - Round `T_eff` to the 3rd significant digit. ```julia -@printf("Time = %1.3f sec, ... \n", t_toc, ...) +@printf("Time = %1.3f sec, T_eff = %1.2f GB/s (niter = %d)\n", t_toc, round(T_eff, sigdigits=3), niter) ``` ### Deactivate visualisation (and error checking) @@ -163,8 +163,10 @@ T_eff = A_eff/t_it # Effective memory throughput [GB/s] - Define a `do_check` flag set to `false` ````julia:ex2 -function Pf_diffusion_2D(;??) +function Pf_diffusion_2D(;do_check=false) + if do_check && (iter%ncheck == 0) ... + end return end ```` @@ -217,19 +219,19 @@ The goal is now to write out the diffusion physics in a loop fashion over $x$ an Implement a nested loop, taking car of bounds and staggering. ````julia:ex6 -for iy=?? - for ix=?? - qDx[??] -= (qDx[??] + k_ηf_dx* ?? )*_1_θ_dτ +for iy=1:ny + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*(Pf[ix+1,iy]-Pf[ix,iy]))*_1_θ_dτ end end -for iy=?? - for ix=?? - qDy[??] -= (qDy[??] + k_ηf_dy* ?? )*_1_θ_dτ +for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*(Pf[ix,iy+1]-Pf[ix,iy]))*_1_θ_dτ end end -for iy=?? - for ix=?? - Pf[??] -= ?? +for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= ((qDx[ix+1,iy]-qDx[ix,iy])*_dx + (qDy[ix,iy+1]-qDy[ix,iy])*_dy)*_β_dτ end end ```` @@ -239,26 +241,26 @@ We could now use macros to make the code nicer and clearer. Macro expression wil Let's use macros to replace the derivative implementations ````julia:ex7 -macro d_xa(A) esc(:( $A[??]-$A[??] )) end -macro d_ya(A) esc(:( $A[??]-$A[??] )) end +macro d_xa(A) esc(:( $A[ix+1,iy]-$A[ix,iy] )) end +macro d_ya(A) esc(:( $A[ix,iy+1]-$A[ix,iy] )) end ```` And update the code within the iteration loop: ````julia:ex8 -for iy=?? - for ix=?? - qDx[??] -= (qDx[??] + k_ηf_dx* ?? )*_1_θ_dτ +for iy=1:ny + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*@d_xa(Pf))*_1_θ_dτ end end -for iy=?? - for ix=?? - qDy[??] -= (qDy[??] + k_ηf_dy* ?? )*_1_θ_dτ +for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*@d_ya(Pf))*_1_θ_dτ end end -for iy=?? - for ix=?? - Pf[??] -= ?? +for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= (@d_xa(qDx)*_dx + @d_ya(qDy)*_dy)*_β_dτ end end ```` @@ -278,15 +280,28 @@ In this last step, the goal is to define `compute` functions to hold the physics Create a `compute_flux!()` and `compute_Pf!()` functions that take input and output arrays and needed scalars as argument and return nothing. ````julia:ex9 -function compute_flux!(...) +function compute_flux!(qDx,qDy,Pf,k_ηf_dx,k_ηf_dy,_1_θ_dτ) nx,ny=size(Pf) - ... + for iy=1:ny, + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*@d_xa(Pf))*_1_θ_dτ + end + end + for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*@d_ya(Pf))*_1_θ_dτ + end + end return nothing end -function update_Pf!(Pf,...) +function update_Pf!(Pf,qDx,qDy,_dx,_dy,_β_dτ) nx,ny=size(Pf) - ... + for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= (@d_xa(qDx)*_dx + @d_ya(qDy)*_dy)*_β_dτ + end + end return nothing end ```` @@ -306,9 +321,9 @@ Let's evaluate the performance of our code using `BenchmarkTools`. We will need The `compute!()` function: ````julia:ex10 -function compute!(Pf,qDx,qDy, ???) - compute_flux!(...) - update_Pf!(...) +function compute!(Pf,qDx,qDy,k_ηf_dx,k_ηf_dy,_1_θ_dτ,_dx,_dy,_β_dτ) + compute_flux!(qDx,qDy,Pf,k_ηf_dx,k_ηf_dy,_1_θ_dτ) + update_Pf!(Pf,qDx,qDy,_dx,_dy,_β_dτ) return nothing end ```` @@ -316,8 +331,8 @@ end can then be called using `@belapsed` to return elapsed time for a single iteration, letting `BenchmarkTools` taking car about sampling ````julia:ex11 -t_toc = @belapsed compute!($Pf,$qDx,$qDy,???) -niter = ??? +t_toc = @belapsed compute!($Pf,$qDx,$qDy,$k_ηf_dx,$k_ηf_dy,$_1_θ_dτ,$_dx,$_dy,$_β_dτ) +niter = 1 ```` \note{Note that variables need to be interpolated into the function call, thus taking a `$` in front.} diff --git a/assets/literate/l5_1-cpu-parallel_web_script.jl b/assets/literate/l5_1-cpu-parallel_web_script.jl index b3190eeb..9895b32b 100644 --- a/assets/literate/l5_1-cpu-parallel_web_script.jl +++ b/assets/literate/l5_1-cpu-parallel_web_script.jl @@ -1,12 +1,14 @@ # This file was generated, do not modify it. -t_toc = ... -A_eff = ... # Effective main memory access per iteration [GB] -t_it = ... # Execution time per iteration [s] -T_eff = A_eff/t_it # Effective memory throughput [GB/s] +t_toc = Base.time() - t_tic +A_eff = (3*2)/1e9*nx*ny*sizeof(Float64) # Effective main memory access per iteration [GB] +t_it = t_toc/niter # Execution time per iteration [s] +T_eff = A_eff/t_it # Effective memory throughput [GB/s] -function Pf_diffusion_2D(;??) +function Pf_diffusion_2D(;do_check=false) + if do_check && (iter%ncheck == 0) ... + end return end @@ -16,58 +18,71 @@ _1_θ_dτ = 1.0./(1.0 + θ_dτ) _dx, _dy = 1.0/dx, 1.0/dy -for iy=?? - for ix=?? - qDx[??] -= (qDx[??] + k_ηf_dx* ?? )*_1_θ_dτ +for iy=1:ny + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*(Pf[ix+1,iy]-Pf[ix,iy]))*_1_θ_dτ end end -for iy=?? - for ix=?? - qDy[??] -= (qDy[??] + k_ηf_dy* ?? )*_1_θ_dτ +for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*(Pf[ix,iy+1]-Pf[ix,iy]))*_1_θ_dτ end end -for iy=?? - for ix=?? - Pf[??] -= ?? +for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= ((qDx[ix+1,iy]-qDx[ix,iy])*_dx + (qDy[ix,iy+1]-qDy[ix,iy])*_dy)*_β_dτ end end -macro d_xa(A) esc(:( $A[??]-$A[??] )) end -macro d_ya(A) esc(:( $A[??]-$A[??] )) end +macro d_xa(A) esc(:( $A[ix+1,iy]-$A[ix,iy] )) end +macro d_ya(A) esc(:( $A[ix,iy+1]-$A[ix,iy] )) end -for iy=?? - for ix=?? - qDx[??] -= (qDx[??] + k_ηf_dx* ?? )*_1_θ_dτ +for iy=1:ny + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*@d_xa(Pf))*_1_θ_dτ end end -for iy=?? - for ix=?? - qDy[??] -= (qDy[??] + k_ηf_dy* ?? )*_1_θ_dτ +for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*@d_ya(Pf))*_1_θ_dτ end end -for iy=?? - for ix=?? - Pf[??] -= ?? +for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= (@d_xa(qDx)*_dx + @d_ya(qDy)*_dy)*_β_dτ end end -function compute_flux!(...) +function compute_flux!(qDx,qDy,Pf,k_ηf_dx,k_ηf_dy,_1_θ_dτ) nx,ny=size(Pf) - ... + for iy=1:ny, + for ix=1:nx-1 + qDx[ix+1,iy] -= (qDx[ix+1,iy] + k_ηf_dx*@d_xa(Pf))*_1_θ_dτ + end + end + for iy=1:ny-1 + for ix=1:nx + qDy[ix,iy+1] -= (qDy[ix,iy+1] + k_ηf_dy*@d_ya(Pf))*_1_θ_dτ + end + end return nothing end -function update_Pf!(Pf,...) +function update_Pf!(Pf,qDx,qDy,_dx,_dy,_β_dτ) nx,ny=size(Pf) - ... + for iy=1:ny + for ix=1:nx + Pf[ix,iy] -= (@d_xa(qDx)*_dx + @d_ya(qDy)*_dy)*_β_dτ + end + end return nothing end -function compute!(Pf,qDx,qDy, ???) - compute_flux!(...) - update_Pf!(...) +function compute!(Pf,qDx,qDy,k_ηf_dx,k_ηf_dy,_1_θ_dτ,_dx,_dy,_β_dτ) + compute_flux!(qDx,qDy,Pf,k_ηf_dx,k_ηf_dy,_1_θ_dτ) + update_Pf!(Pf,qDx,qDy,_dx,_dy,_β_dτ) return nothing end -t_toc = @belapsed compute!($Pf,$qDx,$qDy,???) -niter = ??? +t_toc = @belapsed compute!($Pf,$qDx,$qDy,$k_ηf_dx,$k_ηf_dy,$_1_θ_dτ,$_dx,$_dy,$_β_dτ) +niter = 1 diff --git a/extras/index.html b/extras/index.html index 4658da23..542121d1 100644 --- a/extras/index.html +++ b/extras/index.html @@ -1 +1 @@ - Extras
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Extras

Cheatsheets

References

any further relevant suggestions are welcome - open a PR

Extra material

Julia GPU HPC tutorials and workshops

Other courses and workshops

Repositories

Other resources

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Extras
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Extras

Cheatsheets

References

any further relevant suggestions are welcome - open a PR

Extra material

Julia GPU HPC tutorials and workshops

Other courses and workshops

Repositories

Other resources

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/final_proj/index.html b/final_proj/index.html index e08f6ea9..cb5f060f 100644 --- a/final_proj/index.html +++ b/final_proj/index.html @@ -1 +1 @@ - Information about final projects
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Information about final projects

Final projects will provide 35% of the course grade. We recommend you work in teams of two, but being your own teammate is fine too.

🚧 More infos to come in due time.

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Information about final projects
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Information about final projects

Final projects will provide 35% of the course grade. We recommend you work in teams of two, but being your own teammate is fine too.

🚧 More infos to come in due time.

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/homework/index.html b/homework/index.html index de2b7c90..7faa391c 100644 --- a/homework/index.html +++ b/homework/index.html @@ -1 +1 @@ - Homework
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Homework

AssignmentDue dateSubmissionNotes
Lect. 125.09.2024 - 23h59 CETMoodleSubmit a folder containing all exercise notebooks from JupyterHub.
Lect. 202.10.2024 - 23h59 CETMoodle (notebooks), Moodle (commit hash + PR)For the notebooks submission, submit a folder containing all exercise notebooks from JupyterHub. For the commit hash + PR submission, copy the git commit hash (SHA) of the final push on the branch homework-2 and open a pull request on the main branch. Paste both the commit hash and the PR link on Moodle (check Logistics for more details on how to set up the GitHub repository).
Lect. 311.10.2024 - 23h59 CETMoodle (commit hash + PR)For the submission, copy the git commit hash (SHA) of the final push on the branch homework-3 and open a pull request on the main branch. Paste both the SHA and the PR link on Moodle.
Lect. 418.10.2024 - 23h59 CETMoodle (commit hash + PR)For the submission, copy the git commit hash (SHA) of the final push on the branch homework-4 and open a pull request on the main branch. Paste both the SHA and the PR link on Moodle.
Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Homework
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Homework

AssignmentDue dateSubmissionNotes
Lect. 125.09.2024 - 23h59 CETMoodleSubmit a folder containing all exercise notebooks from JupyterHub.
Lect. 202.10.2024 - 23h59 CETMoodle (notebooks), Moodle (commit hash + PR)For the notebooks submission, submit a folder containing all exercise notebooks from JupyterHub. For the commit hash + PR submission, copy the git commit hash (SHA) of the final push on the branch homework-2 and open a pull request on the main branch. Paste both the commit hash and the PR link on Moodle (check Logistics for more details on how to set up the GitHub repository).
Lect. 311.10.2024 - 23h59 CETMoodle (commit hash + PR)For the submission, copy the git commit hash (SHA) of the final push on the branch homework-3 and open a pull request on the main branch. Paste both the SHA and the PR link on Moodle.
Lect. 418.10.2024 - 23h59 CETMoodle (commit hash + PR)For the submission, copy the git commit hash (SHA) of the final push on the branch homework-4 and open a pull request on the main branch. Paste both the SHA and the PR link on Moodle.
Lect. 525.10.2024 - 23h59 CETMoodle (commit hash + PR)For the submission, copy the git commit hash (SHA) of the final push on the branch homework-5 and open a pull request on the main branch. Paste both the SHA and the PR link on Moodle.
Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/index.html b/index.html index 7de7e7f6..95798a84 100644 --- a/index.html +++ b/index.html @@ -1 +1 @@ - Solving PDEs in parallel on GPUs with Julia
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Solving PDEs in parallel on GPUs with Julia

🎉 Welcome to ETH's course 101-0250-00L on solving partial differential equations (PDEs) in parallel on graphical processing units (GPUs) with the Julia programming language.

💡 Note
2024 edition starts Tuesday Sept. 17, 12h45. Welcome!

Course information

This course aims to cover state-of-the-art methods in modern parallel GPU computing, supercomputing and scientific software development with applications to natural sciences and engineering. The course is open source and is available on GitHub.

Objective

The goal of this course is to offer a practical approach to solve systems of partial differential equations in parallel on GPUs using the Julia programming language. Julia combines high-level language expressiveness and low-level language performance which enables efficient code development. The Julia GPU applications will be hosted on GitHub and implement modern software development practices.

Outline

  • Part 1 Introducing Julia & PDEs

    • The Julia language: hands-on

    • Solving physical processes: advection, reaction, diffusion & wave propagation

    • Spatial and temporal discretisation: finite differences and explicit time-stepping

    • Software development tools: Git, Continuous Integration

  • Part 2 Solving PDEs on GPUs

    • Steady-state, implicit & nonlinear solutions

    • Efficient iterative algorithms

    • Parallel and GPU computing

    • Simulation performance limiters

  • Part 3 Projects

    Multi-GPU computing and optimisations

    • xPU computing

    • Distributed computing

    • Advanced optimisations

  • Final projects

    Solve a solid mechanics or fluid dynamics problem of your interest, such as:

    • dynamic elasticity — seismic wave propagation

    • Maxwell's equations — electromagnetic fields propagation

    • shallow-water equations — rivers, lakes, or oceans

    • shallow ice approximation — ice sheet evolution

    • Navier–Stokes equations — fluid or smoke

    • thermo-mechanically coupled Stokes flow — mantle convection

    • hydro-mechanically coupled Stokes flow — subsurface CO2 flow

    • your own idea

Teaching staff

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Solving PDEs in parallel on GPUs with Julia
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Solving PDEs in parallel on GPUs with Julia

🎉 Welcome to ETH's course 101-0250-00L on solving partial differential equations (PDEs) in parallel on graphical processing units (GPUs) with the Julia programming language.

💡 Note
2024 edition starts Tuesday Sept. 17, 12h45. Welcome!

Course information

This course aims to cover state-of-the-art methods in modern parallel GPU computing, supercomputing and scientific software development with applications to natural sciences and engineering. The course is open source and is available on GitHub.

Objective

The goal of this course is to offer a practical approach to solve systems of partial differential equations in parallel on GPUs using the Julia programming language. Julia combines high-level language expressiveness and low-level language performance which enables efficient code development. The Julia GPU applications will be hosted on GitHub and implement modern software development practices.

Outline

  • Part 1 Introducing Julia & PDEs

    • The Julia language: hands-on

    • Solving physical processes: advection, reaction, diffusion & wave propagation

    • Spatial and temporal discretisation: finite differences and explicit time-stepping

    • Software development tools: Git, Continuous Integration

  • Part 2 Solving PDEs on GPUs

    • Steady-state, implicit & nonlinear solutions

    • Efficient iterative algorithms

    • Parallel and GPU computing

    • Simulation performance limiters

  • Part 3 Projects

    Multi-GPU computing and optimisations

    • xPU computing

    • Distributed computing

    • Advanced optimisations

  • Final projects

    Solve a solid mechanics or fluid dynamics problem of your interest, such as:

    • dynamic elasticity — seismic wave propagation

    • Maxwell's equations — electromagnetic fields propagation

    • shallow-water equations — rivers, lakes, or oceans

    • shallow ice approximation — ice sheet evolution

    • Navier–Stokes equations — fluid or smoke

    • thermo-mechanically coupled Stokes flow — mantle convection

    • hydro-mechanically coupled Stokes flow — subsurface CO2 flow

    • your own idea

Teaching staff

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/lecture1/index.html b/lecture1/index.html index bdd54d2c..ab580487 100644 --- a/lecture1/index.html +++ b/lecture1/index.html @@ -730,7 +730,7 @@

Question 2
Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture10/index.html b/lecture10/index.html index f0c5695c..7a66178d 100644 --- a/lecture10/index.html +++ b/lecture10/index.html @@ -417,7 +417,7 @@

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language. diff --git a/lecture2/index.html b/lecture2/index.html index eab79d01..8dabbb07 100644 --- a/lecture2/index.html +++ b/lecture2/index.html @@ -565,7 +565,7 @@

GitHub task<
Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture3/index.html b/lecture3/index.html index 4f0eecd6..e3138e82 100644 --- a/lecture3/index.html +++ b/lecture3/index.html @@ -445,7 +445,7 @@

Task 1

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture4/index.html b/lecture4/index.html index 7ac8f6e2..2bdf246e 100644 --- a/lecture4/index.html +++ b/lecture4/index.html @@ -231,7 +231,7 @@

Task 3

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture5/index.html b/lecture5/index.html index 9a5e0739..34e47443 100644 --- a/lecture5/index.html +++ b/lecture5/index.html @@ -1,7 +1,7 @@ - Lecture 5
Fall 2024 | ETHZ 101-0250-00

Solving partial differential equations in parallel on GPUs

by   Ludovic Räss,   Mauro Werder,   Samuel Omlin &
Ivan Utkin



Lecture 5

Agenda
📚 Parallel computing on CPUs & performance assessment, the TeffT_\mathrm{eff} metric
💻 Unit testing in Julia
🚧 Exercises:

  • CPU perf. codes for 2D diffusion and memcopy

  • Unit tests and testset implementation

Content

  1. Lecture 5
  2. Parallel computing (on CPUs) and performance assessment
    1. Performance
    2. Performance limiters
    3. Effective memory throughput metric TeffT_\mathrm{eff}
    4. Parallel computing on CPUs
    5. Shared memory parallelisation
  3. Unit testing in Julia
    1. Basic unit tests
    2. Working with a test sets
  4. Exercises - lecture 5
    1. Exercise 1 — Performance implementation
    2. Exercise 2 — Performance evaluation
    3. Exercise 3 — Unit tests

👉 get started with exercises

Parallel computing (on CPUs) and performance assessment

Performance

❓ some questions for you:

  • How to assess the performance of numerical application?

  • Are you familiar the concept of wall-time?

  • What are the key ingredients to understand performance?

The goal of this lecture 5 is to introduce:

  • Performance limiters

  • Effective memory throughput metric TeffT_\mathrm{eff}

  • Parallel computing on CPUs

  • Shared memory parallelisation

Performance limiters

Hardware

  • Recent processors (CPUs and GPUs) have multiple (or many) cores

  • Recent processors use their parallelism to hide latency (i.e. overlapping execution times (latencies) of individual operations with execution times of other operations)

  • Multi-core CPUs and GPUs share similar challenges

Recall from lecture 1 (why we do it) ...

Use parallel computing (to address this):

  • The "memory wall" in ~ 2004

  • Single-core to multi-core devices

mem_wall

GPUs are massively parallel devices

  • SIMD machine (programmed using threads - SPMD) (more)

  • Further increases the FLOPS vs Bytes gap

cpu_gpu_evo

Taking a look at a recent GPU and CPU:

  • Nvidia Tesla A100 GPU

  • AMD EPYC "Rome" 7282 (16 cores) CPU

DeviceTFLOP/s (FP64)Memory BW TB/s
Tesla A1009.71.55
AMD EPYC 72820.70.085

Current GPUs (and CPUs) can do many more computations in a given amount of time than they can access numbers from main memory.

Quantify the imbalance:

computation peak performance [TFLOP/s]memory access peak performance [TB/s]×size of a number [Bytes] \frac{\mathrm{computation\;peak\;performance\;[TFLOP/s]}}{\mathrm{memory\;access\;peak\;performance\;[TB/s]}} × \mathrm{size\;of\;a\;number\;[Bytes]}

(Theoretical peak performance values as specified by the vendors can be used).

Back to our hardware:

DeviceTFLOP/s (FP64)Memory BW TB/sImbalance (FP64)
Tesla A1009.71.559.7 / 1.55 × 8 = 50
AMD EPYC 72820.70.0850.7 / 0.085 × 8 = 66

(here computed with double precision values)

Meaning: we can do 50 (GPU) and 66 (CPU) floating point operations per number accessed from main memory. Floating point operations are "for free" when we work in memory-bounded regimes

➡ Requires to re-think the numerical implementation and solution strategies

On the scientific application side

  • Most algorithms require only a few operations or FLOPS ...

  • ... compared to the amount of numbers or bytes accessed from main memory.

First derivative example ∂A/∂x∂A / ∂x:

If we "naively" compare the "cost" of an isolated evaluation of a finite-difference first derivative, e.g., computing a flux qq:

q=−D ∂A∂x ,q = -D~\frac{∂A}{∂x}~,

which in the discrete form reads q[ix] = -D*(A[ix+1]-A[ix])/dx.

The cost of evaluating q[ix] = -D*(A[ix+1]-A[ix])/dx:

1 reads + 1 write => 2×82 × 8 = 16 Bytes transferred

1 (fused) addition and division => 1 floating point operation

assuming:

  • DD, ∂x∂x are scalars

  • qq and AA are arrays of Float64 (read from main memory)

GPUs and CPUs perform 50 - 60 floating-point operations per number accessed from main memory

First derivative evaluation requires to transfer 2 numbers per floating-point operations

The FLOPS metric is no longer the most adequate for reporting the application performance of many modern applications on modern hardware.

Effective memory throughput metric TeffT_\mathrm{eff}

Need for a memory throughput-based performance evaluation metric: TeffT_\mathrm{eff} [GB/s]

➡ Evaluate the performance of iterative stencil-based solvers.

The effective memory access AeffA_\mathrm{eff} [GB]

Sum of:

  • twice the memory footprint of the unknown fields, DuD_\mathrm{u}, (fields that depend on their own history and that need to be updated every iteration)

  • known fields, DkD_\mathrm{k}, that do not change every iteration.

The effective memory access divided by the execution time per iteration, titt_\mathrm{it} [sec], defines the effective memory throughput, TeffT_\mathrm{eff} [GB/s]:

Aeff=2 Du+Dk A_\mathrm{eff} = 2~D_\mathrm{u} + D_\mathrm{k} Teff=Aefftit T_\mathrm{eff} = \frac{A_\mathrm{eff}}{t_\mathrm{it}}

The upper bound of TeffT_\mathrm{eff} is TpeakT_\mathrm{peak} as measured, e.g., by McCalpin, 1995 for CPUs or a GPU analogue.

Defining the TeffT_\mathrm{eff} metric, we assume that:

  1. we evaluate an iterative stencil-based solver,

  2. the problem size is much larger than the cache sizes and

  3. the usage of time blocking is not feasible or advantageous (reasonable for real-world applications).

💡 Note
Fields within the effective memory access that do not depend on their own history; such fields can be re-computed on the fly or stored on-chip.

As first task, we'll compute the TeffT_\mathrm{eff} for the 2D fluid pressure (diffusion) solver at the core of the porous convection algorithm from previous lecture.

👉 Download the script l5_Pf_diffusion_2D.jl to get started.

To-do list:

  • copy l5_Pf_diffusion_2D.jl, rename it to Pf_diffusion_2D_Teff.jl

  • add a timer

  • include the performance metric formulas

  • deactivate visualisation

💻 Let's get started

Timer and performance

  • Use Base.time() to return the current timestamp

  • Define t_tic, the starting time, after 11 iterations steps to allow for "warm-up"

  • Record the exact number of iterations (introduce e.g. niter)

  • Compute the elapsed time t_toc at the end of the time loop and report:

t_toc = ...
-A_eff = ...          # Effective main memory access per iteration [GB]
-t_it  = ...          # Execution time per iteration [s]
-T_eff = A_eff/t_it   # Effective memory throughput [GB/s]

  • Report t_toc, T_eff and niter at the end of the code, formatting output using @printf() macro.

  • Round T_eff to the 3rd significant digit.

@printf("Time = %1.3f sec, ... \n", t_toc, ...)
+ Lecture 5

Solving partial differential equations in parallel on GPUs




Lecture 5

Agenda
📚 Parallel computing on CPUs & performance assessment, the TeffT_\mathrm{eff} metric
💻 Unit testing in Julia
🚧 Exercises:

  • CPU perf. codes for 2D diffusion and memcopy

  • Unit tests and testset implementation

Content

  1. Lecture 5
  2. Parallel computing (on CPUs) and performance assessment
    1. Performance
    2. Performance limiters
    3. Effective memory throughput metric TeffT_\mathrm{eff}
    4. Parallel computing on CPUs
    5. Shared memory parallelisation
  3. Unit testing in Julia
    1. Basic unit tests
    2. Working with a test sets
  4. Exercises - lecture 5
    1. Exercise 1 — Performance implementation
    2. Exercise 2 — Performance evaluation
    3. Exercise 3 — Unit tests

👉 get started with exercises

Parallel computing (on CPUs) and performance assessment

Performance

❓ some questions for you:

  • How to assess the performance of numerical application?

  • Are you familiar the concept of wall-time?

  • What are the key ingredients to understand performance?

The goal of this lecture 5 is to introduce:

  • Performance limiters

  • Effective memory throughput metric TeffT_\mathrm{eff}

  • Parallel computing on CPUs

  • Shared memory parallelisation

Performance limiters

Hardware

  • Recent processors (CPUs and GPUs) have multiple (or many) cores

  • Recent processors use their parallelism to hide latency (i.e. overlapping execution times (latencies) of individual operations with execution times of other operations)

  • Multi-core CPUs and GPUs share similar challenges

Recall from lecture 1 (why we do it) ...

Use parallel computing (to address this):

  • The "memory wall" in ~ 2004

  • Single-core to multi-core devices

mem_wall

GPUs are massively parallel devices

  • SIMD machine (programmed using threads - SPMD) (more)

  • Further increases the FLOPS vs Bytes gap

cpu_gpu_evo

Taking a look at a recent GPU and CPU:

  • Nvidia Tesla A100 GPU

  • AMD EPYC "Rome" 7282 (16 cores) CPU

DeviceTFLOP/s (FP64)Memory BW TB/s
Tesla A1009.71.55
AMD EPYC 72820.70.085

Current GPUs (and CPUs) can do many more computations in a given amount of time than they can access numbers from main memory.

Quantify the imbalance:

computation peak performance [TFLOP/s]memory access peak performance [TB/s]×size of a number [Bytes] \frac{\mathrm{computation\;peak\;performance\;[TFLOP/s]}}{\mathrm{memory\;access\;peak\;performance\;[TB/s]}} × \mathrm{size\;of\;a\;number\;[Bytes]}

(Theoretical peak performance values as specified by the vendors can be used).

Back to our hardware:

DeviceTFLOP/s (FP64)Memory BW TB/sImbalance (FP64)
Tesla A1009.71.559.7 / 1.55 × 8 = 50
AMD EPYC 72820.70.0850.7 / 0.085 × 8 = 66

(here computed with double precision values)

Meaning: we can do 50 (GPU) and 66 (CPU) floating point operations per number accessed from main memory. Floating point operations are "for free" when we work in memory-bounded regimes

➡ Requires to re-think the numerical implementation and solution strategies

On the scientific application side

  • Most algorithms require only a few operations or FLOPS ...

  • ... compared to the amount of numbers or bytes accessed from main memory.

First derivative example ∂A/∂x∂A / ∂x:

If we "naively" compare the "cost" of an isolated evaluation of a finite-difference first derivative, e.g., computing a flux qq:

q=−D ∂A∂x ,q = -D~\frac{∂A}{∂x}~,

which in the discrete form reads q[ix] = -D*(A[ix+1]-A[ix])/dx.

The cost of evaluating q[ix] = -D*(A[ix+1]-A[ix])/dx:

1 reads + 1 write => 2×82 × 8 = 16 Bytes transferred

1 (fused) addition and division => 1 floating point operation

assuming:

  • DD, ∂x∂x are scalars

  • qq and AA are arrays of Float64 (read from main memory)

GPUs and CPUs perform 50 - 60 floating-point operations per number accessed from main memory

First derivative evaluation requires to transfer 2 numbers per floating-point operations

The FLOPS metric is no longer the most adequate for reporting the application performance of many modern applications on modern hardware.

Effective memory throughput metric TeffT_\mathrm{eff}

Need for a memory throughput-based performance evaluation metric: TeffT_\mathrm{eff} [GB/s]

➡ Evaluate the performance of iterative stencil-based solvers.

The effective memory access AeffA_\mathrm{eff} [GB]

Sum of:

  • twice the memory footprint of the unknown fields, DuD_\mathrm{u}, (fields that depend on their own history and that need to be updated every iteration)

  • known fields, DkD_\mathrm{k}, that do not change every iteration.

The effective memory access divided by the execution time per iteration, titt_\mathrm{it} [sec], defines the effective memory throughput, TeffT_\mathrm{eff} [GB/s]:

Aeff=2 Du+Dk A_\mathrm{eff} = 2~D_\mathrm{u} + D_\mathrm{k} Teff=Aefftit T_\mathrm{eff} = \frac{A_\mathrm{eff}}{t_\mathrm{it}}

The upper bound of TeffT_\mathrm{eff} is TpeakT_\mathrm{peak} as measured, e.g., by McCalpin, 1995 for CPUs or a GPU analogue.

Defining the TeffT_\mathrm{eff} metric, we assume that:

  1. we evaluate an iterative stencil-based solver,

  2. the problem size is much larger than the cache sizes and

  3. the usage of time blocking is not feasible or advantageous (reasonable for real-world applications).

💡 Note
Fields within the effective memory access that do not depend on their own history; such fields can be re-computed on the fly or stored on-chip.

As first task, we'll compute the TeffT_\mathrm{eff} for the 2D fluid pressure (diffusion) solver at the core of the porous convection algorithm from previous lecture.

👉 Download the script l5_Pf_diffusion_2D.jl to get started.

To-do list:

  • copy l5_Pf_diffusion_2D.jl, rename it to Pf_diffusion_2D_Teff.jl

  • add a timer

  • include the performance metric formulas

  • deactivate visualisation

💻 Let's get started

Timer and performance

  • Use Base.time() to return the current timestamp

  • Define t_tic, the starting time, after 11 iterations steps to allow for "warm-up"

  • Record the exact number of iterations (introduce e.g. niter)

  • Compute the elapsed time t_toc at the end of the time loop and report:

t_toc = Base.time() - t_tic
+A_eff = (3*2)/1e9*nx*ny*sizeof(Float64)  # Effective main memory access per iteration [GB]
+t_it  = t_toc/niter                      # Execution time per iteration [s]
+T_eff = A_eff/t_it                       # Effective memory throughput [GB/s]

  • Report t_toc, T_eff and niter at the end of the code, formatting output using @printf() macro.

  • Round T_eff to the 3rd significant digit.

@printf("Time = %1.3f sec, T_eff = %1.2f GB/s (niter = %d)\n", t_toc, round(T_eff, sigdigits=3), niter)

Deactivate visualisation (and error checking)

diff --git a/lecture7/index.html b/lecture7/index.html index cc3eafba..c7d33359 100644 --- a/lecture7/index.html +++ b/lecture7/index.html @@ -491,7 +491,7 @@

Tasks

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture8/index.html b/lecture8/index.html index d8469580..ccd4617f 100644 --- a/lecture8/index.html +++ b/lecture8/index.html @@ -322,7 +322,7 @@

Task 6

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
diff --git a/lecture9/index.html b/lecture9/index.html index 7e75a156..b620c518 100644 --- a/lecture9/index.html +++ b/lecture9/index.html @@ -421,7 +421,7 @@

Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language. diff --git a/logistics/index.html b/logistics/index.html index 498a87bd..a9a8f329 100644 --- a/logistics/index.html +++ b/logistics/index.html @@ -1 +1 @@ - Logistics

Solving partial differential equations in parallel on GPUs




Logistics

Element chat Zoom Meeting ETHZ Moodle

Suggestion: Bookmark this page for easy access to all infos you need for the course.

Course structure

Each lecture contains material on physics, numerics, technical concepts, as well as exercises. The lecture content is outlined in its introduction using the following items for each type of content:

  • 📚 Physics: equations, discretisation, implementation, solver, visualisation

  • 💻 Code: technical, Julia, GitHub

  • 🚧 Exercises

The course will be taught in a hands-on fashion, putting emphasis on you writing code and completing exercises; lecturing will be kept at a minimum.

Lectures

Live lectures | Tuesdays 12h45-15h30

  • Lectures will take place in HCI E8

  • Online attendance will be possible on Zoom for ETH students only

  • No online support will be provided during the exercise session, please follow the lectures

Office hours

Schedule will be defined and communicated on the last lecture.

Discussion

We use Element as the main channel for communication between the teachers and the students, and hopefully also between students. We encourage ETH students to ask and answer questions related to the course, exercises and projects there.

Head to the Element chat link on Moodle to get started with Element:

  1. Select Start Student-Chat

  2. Login using your NETHZ credentials to start using the browser-based client

  3. Join the General and Helpdesk rooms

  4. Download the desktop or mobile client for more convenient access or in case of encryption-related issues

Homework

Homework tasks will be announced after each week's lecture. The exercise session following the lecture will get you started.

Homework due date will be Wednesday 23h59 CET every following week (8 days) to allow for Q&A during the following in-class exercise session.

All homework assignments can be carried out by groups of two. However, note that every student has to hand in a personal version of the homework.

➡ Check out the Homework page for an overview on expected hand-in and deadlines.

Submission

  • Submission of JupyterHub notebooks after weeks 1 and 2, then GitHub commit hash (SHA) after week 3 and onwards, or other documents happens on the course's Moodle.

  • Actions and tasks related to GitHub will happen on your private course-related GitHub repository.

Starting from lecture 3 and onwards, the development of homework scripts happens on GitHub and you will have to submit the git commit hash (SHA) on Moodle in the related git commit hash (SHA) submission activity.

Submission for Jupyter Hub to Moodle

  • on the Hub place all notebooks of an assignment into one folder called assignments/lectureX_homework

    • note: maybe this folder magically already exists on your Hub with the notebooks added. If not, create it and download the notebooks yourself.

  • in Moodle during submission, select that folder as JupyterHub submission

Private GitHub repository setup

Once you have your GitHub account ready (see lecture 2 how-to), create a private repository you will share with the teaching staff only to upload your weekly assignments:

  1. Create a private GitHub repository named pde-on-gpu-<moodleprofilename>, where <moodleprofilename> has to be replaced by your name as displayed on Moodle, lowercase, diacritics removed, spacing replaced with hyphens (-). For example, if your Moodle profile name is "Joël Désirée van der Linde" your repository should be named pde-on-gpu-joel-desiree-van-der-linde.

  2. Select an MIT License and add a README.md file.

  3. Share this private repository on GitHub with the teaching bot.

  4. For each homework submission, you will:

    • create a git branch named homework-X (X ∈[2−...]\in [2-...]) and switch to that branch (git switch -c homework-X);

    • create a new folder named homework-X to put the exercise codes into;

    • (don't forget to git add the code-files and git commit them);

    • push to GitHub and open a pull request (PR) on the main branch on GitHub;

    • copy the single git commit hash (SHA) after the final push and the link to the PR and submit both on Moodle as the assignment hand-in (it will serve to control the material was pushed on time);

    • (do not merge the PR yet).

⚠️ Warning!
Make sure to only include the homework-X folders and README.md in the GitHub repo you share with the exercise bot in order to keep the repository lightweight.
💡 Note
For homework 3 and later, the respective folders on GitHub should be Julia projects and thus must contain a Project.toml file. The Manifest.toml file should be excluded from version control. To do so, add it as entry to a .gitignore file in the root of your repo. Mac users may also add .DS_Store to their global .gitignore. Codes could be placed in a scripts/ folder. Output material to be displayed in the README.md could be placed in a docs/ folder.

Feedback

After the submission deadline, we will correct and grade your assignments. You will get personal feedback directly on the PR as well as on Moodle. Once you got feedback, please merge the PR.

We will try to correct your assignments before the lecture following the homework's deadline. This should allow you to get rapid feedback in order to clarify the points you may struggle on as soon as possible.

Project

Starting from lecture 7, and until lecture 9, homework assigments contribute to the course's first project. The goal of this project is to have a multi-xPU thermal porous convection solver in 3D.

🚧 More infos to come in due time.

Evaluation

All homework assigments can be done alone or in groups of two.

Enrolled ETHZ students will have to hand in on Moodle and GitHub:

  1. Six weekly assignments during the course's Part 1 and Part 2 constitute 30% of the final grade. The best five out of six homeworks will be counted.

  2. A project developed during Part 3 of the course consitutes 35% of the final grade

  3. A final project consitutes 35% of the final grade

Project submission includes code in a Github repository and an automatically generated documentation.

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Logistics

Solving partial differential equations in parallel on GPUs




Logistics

Element chat Zoom Meeting ETHZ Moodle

Suggestion: Bookmark this page for easy access to all infos you need for the course.

Course structure

Each lecture contains material on physics, numerics, technical concepts, as well as exercises. The lecture content is outlined in its introduction using the following items for each type of content:

  • 📚 Physics: equations, discretisation, implementation, solver, visualisation

  • 💻 Code: technical, Julia, GitHub

  • 🚧 Exercises

The course will be taught in a hands-on fashion, putting emphasis on you writing code and completing exercises; lecturing will be kept at a minimum.

Lectures

Live lectures | Tuesdays 12h45-15h30

  • Lectures will take place in HCI E8

  • Online attendance will be possible on Zoom for ETH students only

  • No online support will be provided during the exercise session, please follow the lectures

Office hours

Schedule will be defined and communicated on the last lecture.

Discussion

We use Element as the main channel for communication between the teachers and the students, and hopefully also between students. We encourage ETH students to ask and answer questions related to the course, exercises and projects there.

Head to the Element chat link on Moodle to get started with Element:

  1. Select Start Student-Chat

  2. Login using your NETHZ credentials to start using the browser-based client

  3. Join the General and Helpdesk rooms

  4. Download the desktop or mobile client for more convenient access or in case of encryption-related issues

Homework

Homework tasks will be announced after each week's lecture. The exercise session following the lecture will get you started.

Homework due date will be Wednesday 23h59 CET every following week (8 days) to allow for Q&A during the following in-class exercise session.

All homework assignments can be carried out by groups of two. However, note that every student has to hand in a personal version of the homework.

➡ Check out the Homework page for an overview on expected hand-in and deadlines.

Submission

  • Submission of JupyterHub notebooks after weeks 1 and 2, then GitHub commit hash (SHA) after week 3 and onwards, or other documents happens on the course's Moodle.

  • Actions and tasks related to GitHub will happen on your private course-related GitHub repository.

Starting from lecture 3 and onwards, the development of homework scripts happens on GitHub and you will have to submit the git commit hash (SHA) on Moodle in the related git commit hash (SHA) submission activity.

Submission for Jupyter Hub to Moodle

  • on the Hub place all notebooks of an assignment into one folder called assignments/lectureX_homework

    • note: maybe this folder magically already exists on your Hub with the notebooks added. If not, create it and download the notebooks yourself.

  • in Moodle during submission, select that folder as JupyterHub submission

Private GitHub repository setup

Once you have your GitHub account ready (see lecture 2 how-to), create a private repository you will share with the teaching staff only to upload your weekly assignments:

  1. Create a private GitHub repository named pde-on-gpu-<moodleprofilename>, where <moodleprofilename> has to be replaced by your name as displayed on Moodle, lowercase, diacritics removed, spacing replaced with hyphens (-). For example, if your Moodle profile name is "Joël Désirée van der Linde" your repository should be named pde-on-gpu-joel-desiree-van-der-linde.

  2. Select an MIT License and add a README.md file.

  3. Share this private repository on GitHub with the teaching bot.

  4. For each homework submission, you will:

    • create a git branch named homework-X (X ∈[2−...]\in [2-...]) and switch to that branch (git switch -c homework-X);

    • create a new folder named homework-X to put the exercise codes into;

    • (don't forget to git add the code-files and git commit them);

    • push to GitHub and open a pull request (PR) on the main branch on GitHub;

    • copy the single git commit hash (SHA) after the final push and the link to the PR and submit both on Moodle as the assignment hand-in (it will serve to control the material was pushed on time);

    • (do not merge the PR yet).

⚠️ Warning!
Make sure to only include the homework-X folders and README.md in the GitHub repo you share with the exercise bot in order to keep the repository lightweight.
💡 Note
For homework 3 and later, the respective folders on GitHub should be Julia projects and thus must contain a Project.toml file. The Manifest.toml file should be excluded from version control. To do so, add it as entry to a .gitignore file in the root of your repo. Mac users may also add .DS_Store to their global .gitignore. Codes could be placed in a scripts/ folder. Output material to be displayed in the README.md could be placed in a docs/ folder.

Feedback

After the submission deadline, we will correct and grade your assignments. You will get personal feedback directly on the PR as well as on Moodle. Once you got feedback, please merge the PR.

We will try to correct your assignments before the lecture following the homework's deadline. This should allow you to get rapid feedback in order to clarify the points you may struggle on as soon as possible.

Project

Starting from lecture 7, and until lecture 9, homework assigments contribute to the course's first project. The goal of this project is to have a multi-xPU thermal porous convection solver in 3D.

🚧 More infos to come in due time.

Evaluation

All homework assigments can be done alone or in groups of two.

Enrolled ETHZ students will have to hand in on Moodle and GitHub:

  1. Six weekly assignments during the course's Part 1 and Part 2 constitute 30% of the final grade. The best five out of six homeworks will be counted.

  2. A project developed during Part 3 of the course consitutes 35% of the final grade

  3. A final project consitutes 35% of the final grade

Project submission includes code in a Github repository and an automatically generated documentation.

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 6354e2de..803cadc6 100644 --- a/package-lock.json +++ b/package-lock.json @@ -209,22 +209,22 @@ } }, "node_modules/parse5": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", - "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.0.tgz", + "integrity": "sha512-ZkDsAOcxsUMZ4Lz5fVciOehNcJ+Gb8gTzcA4yl3wnc273BAybYWrQ+Ks/OjCjSEpjvQkDSeZbybK9qj2VHHdGA==", "dependencies": { - "entities": "^4.4.0" + "entities": "^4.5.0" }, "funding": { "url": "https://github.com/inikulin/parse5?sponsor=1" } }, "node_modules/parse5-htmlparser2-tree-adapter": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.0.0.tgz", - "integrity": "sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz", + "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==", "dependencies": { - "domhandler": "^5.0.2", + "domhandler": "^5.0.3", "parse5": "^7.0.0" }, "funding": { @@ -248,9 +248,9 @@ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" }, "node_modules/undici": { - "version": "6.19.8", - "resolved": "https://registry.npmjs.org/undici/-/undici-6.19.8.tgz", - "integrity": "sha512-U8uCCl2x9TK3WANvmBavymRzxbfFYG+tAu+fgx3zxQy3qdagQqBLwJVrdyO1TBfUXvfKveMKJZhpvUYoOjM+4g==", + "version": "6.20.1", + "resolved": "https://registry.npmjs.org/undici/-/undici-6.20.1.tgz", + "integrity": "sha512-AjQF1QsmqfJys+LXfGTNum+qw4S88CojRInG/6t31W/1fk6G59s92bnAvGz5Cmur+kQv2SURXEvvudLmbrE8QA==", "engines": { "node": ">=18.17" } diff --git a/search/index.html b/search/index.html index de7e2095..4d0e7c02 100644 --- a/search/index.html +++ b/search/index.html @@ -1 +1 @@ - Search ⋅ YourWebsite

Solving partial differential equations in parallel on GPUs




Number of results found:

Edit this page on
Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file + Search ⋅ YourWebsite

Solving partial differential equations in parallel on GPUs




Number of results found:

Edit this page on
Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.
\ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index 5c8e3aee..b732848e 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -3,103 +3,103 @@ https://pde-on-gpu.vaw.ethz.ch/lecture6/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture4/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture2/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture8/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/software_install/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/logistics/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture3/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture10/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/homework/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture1/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/search/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/final_proj/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/extras/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture5/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture7/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/lecture9/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 https://pde-on-gpu.vaw.ethz.ch/index.html - 2024-10-08 + 2024-10-15 monthly 0.5 diff --git a/software_install/index.html b/software_install/index.html index df52a33d..5b294df9 100644 --- a/software_install/index.html +++ b/software_install/index.html @@ -103,7 +103,7 @@

Julia on GPU
Edit this page on
- Last modified: October 08, 2024. Website built with Franklin.jl and the Julia programming language. + Last modified: October 15, 2024. Website built with Franklin.jl and the Julia programming language.