YT YouTube2Text

YouTube2Text → Transcripts → ARCHER2: HEC-WSI webinar

ARCHER2: HEC-WSI webinar — Transcript

by ARCHER2 HPC · 8,157 words · 1,166 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:04Um hi everyone. So I think we're ready
0:06to get started. Welcome to this um
0:09latest Archer 2 webinar. Today we'll be
0:12hearing from the HEC WSI which is the
0:15high-end computing consortium for wave
0:18structure interaction. uh and they we
0:20have three speakers today presenting a
0:22series of talks which we've titled from
0:24GPU accelerated open foam to
0:27highfidelity modeling of offshore
0:29floating wind turbines. So hopefully
0:31three really interesting topics for you
0:33to listen to today. Um each of them will
0:35be giving a 15minute presentation and
0:37then we'll have a little bit of time for
0:38questions in between.
0:41So without further ado, we have uh Liga
0:44Xiao discussing a numerical study on the
0:47interaction of breaking waves and an
0:49offshore floating wind turbine under
0:51realistic sea states. So um over to you.
0:55>> Okay. Thank you very much. Um thanks for
0:58the invitation from March 2. Um it's a
1:02great honor to to have this presentation
1:06uh here. So uh a bit introduction of
1:09myself. So I'm li uh I'm currently the
1:13administrator of hack WSI project and uh
1:16also I'm a PhD student who is doing uh
1:20who is under the topic of wave structure
1:22interaction. Um so today I will
1:26introduce um give a brief introduction
1:29of our project and um to showcase of my
1:33uh study and how I you utilize this
1:36archer to resources on my PhD study. Um
1:41so here we go. Uh so first all about us.
1:46Uh so uh hack WSI uh so we are focusing
1:49on the wave structure interaction
1:51research and uh uh our we have uh m we
1:56support multiple uh projects on the
1:59topic of um this uh numerical studies of
2:03structure uh interaction. Um this
2:06project is currently led by uh
2:09University of Oxford and we have um uh
2:13over 10 um institutions uh cooperate
2:17together um working on this project. Um
2:21so
2:22here comes to my PhD uh research topic
2:27uh the interaction of uh breaking waves
2:30and the offshore wind tub. So today I
2:33would like to um introduce my research
2:37uh from five aspects. So from uh
2:40convergence study uh with a a brief
2:43literature review uh to um go a bit
2:46further to uh present some turbulence
2:49studies some interesting phenomenons um
2:53when the breaking wave come
2:56the turbulence issue. And um next I will
3:00uh further introduce my another work is
3:02about the way breaking over the
3:05realistic safe states and then I will
3:07present our experiment and numerical
3:10work on the uh breaking way breaking
3:13with the floating offshore wind. So
3:16first of all is the uh the background of
3:20my study. So offshore wind um from the
3:24from the onore onshore fixed um
3:27foundation now it's uh in a rapidly uh
3:32change uh moving into the deep water. So
3:35we can say from this slide that um uh we
3:39have a lot of different types of um um
3:44offshore wind foundations. Um so uh like
3:48in this picture shows um some
3:50demonstration projects which means those
3:53type of foundations is already has been
3:56puted in the sea and has been tested uh
4:00of their uh survivability. Um and the
4:03the the um win turban uh wind farm
4:08currently is moving um up to like 900 m
4:13deep in the water. So we can imagine
4:16this um environmental condition of the
4:19wind farm will be uh very harsh very um
4:22we will face a lot of uh very uh heavy
4:26um uh ocean uh sea sea conditions. So
4:31way breaking comes to a a topic uh in
4:35this regard uh because waying is um seen
4:39as the one the most severe uh uh
4:44environmental condition for the offshore
4:47winterban and uh the breaking wave force
4:51was uh is considered at the highest
4:53hydrodnamic loads on the uh on offshore
4:57wind turban. Um so this is the bit
5:00background of uh offshore winterban and
5:04also the way breaking. Um so uh I want
5:09to introduce further the background of
5:10how people in uh investigate the way
5:13breaking on the oures.
5:16Uh we can say from this slides um so um
5:20people have um from the failed test. So
5:25from the uh real offshore sea um
5:30um offshore sea projects have been uh
5:33monitoring the the um for example the
5:36left picture the breaking wave uh breaks
5:39on the offshore brick water. So we can
5:43say it's very violent and um um was
5:46considered. So the the signals from uh
5:49the realistic um um instruments was um
5:54monitoring this breaking wave force and
5:57showing is it has very high peak
6:00pressure and the the duration of this
6:03impact is very very short and um so it's
6:07very hard actually to capture it um in
6:10the field test and uh in the in this uh
6:14slide on the right side is how people uh
6:18gave an example of how people um
6:20capturing this breaking wave um force on
6:24the like this floating winterband
6:27foundation uh how this was been detected
6:31in the in the uh laboratory. Um so
6:38next picture I want to show another
6:40aspect of how people study this topic is
6:43the numerical um method. So we can say
6:47from this is a brief literature um
6:50presentation of um a lot of different um
6:54numerical models to simulate try to
6:56simulate the breaking wave with
6:58different types of um offshore uh
7:01structures. Um uh and this is the uh
7:06kind of the recent progress of this
7:08numerical models. um um so here I found
7:13this uh very important to do the
7:17convergence study um on this topic. So
7:21in this picture the left side is the um
7:25some different numerical models um to
7:28simulate the v breaking uh so um from
7:33using uh the toes from open form um
7:37ances or 3D or even some langian
7:41methods. Um the right side is a basic
7:47literature review of how people uh try
7:50to simulate the breaking wave. Um from
7:55uh volume fluid method. Uh um so we can
8:01see from this picture this um the
8:05summary of different literature view
8:07actually using different um par
8:12parameters setups to simulate the way
8:15breaking and it's quite different uh
8:17ranging like this um MCN represent the
8:21minimum current number so from we can
8:24say from 0.05 05 to one. So it's
8:27actually quite a large large range and
8:30it's not consistent. Haven't got um a
8:33conclusion on this aspect. So this is
8:36why I think to do a convergence study is
8:39very important um on like accurately
8:43capturing the the violent um free
8:47surface. Um so um by using Archer 2,
8:52thanks for Archer 2's support. Um I have
8:55did a lot of uh convergence study um by
8:59um validate different published uh
9:03physical tests and uh to validate um the
9:07breaking wave um time series on the
9:10breaking process and also on the um the
9:14force um on the
9:17uh offshore wind foundations and uh I
9:21have par I have uh used different par
9:24parameters to to uh standardize the um
9:30how to simulate the breaking wave and
9:32gave uh some conclusions on this um this
9:37setups. So which can give um a lot of um
9:41researchers a guidance of how to
9:44accurately simulate way breaking um and
9:47we got some good results here. So these
9:50are validated from um a dimact project
9:53which I have showed in the previous um
9:56uh slides. Um so
10:01this work has been
10:04published and presented on last year in
10:07the ISOP conference. Um and further I
10:10have been study on the turbulence model
10:13which I found is also very essential to
10:15to simulate the wave breaking. Uh this
10:18is originally because I found using runs
10:22model which is very widely used for
10:27simulate way breaking is actually not
10:29very good uh um in uh in simulating the
10:34the high frequency uh wave uh waves. So
10:40my
10:41so from this p uh slide we can say uh uh
10:45the top two uh w gauge uh results
10:48showing is very the the numerical result
10:50is very uh it's not very consistent with
10:54the experiment result um um which shows
10:59uh how high frequency waves are hard to
11:02is hard to simulate it. So my my uh
11:06method is to
11:08study different um turbulence models
11:11from runs to uh detached addi to large
11:15adi models. So in this work I have been
11:20um um studied uh five different uh
11:24turbulence models on simulating the same
11:26exactly same uh breaking wave cases. Um
11:32and I got some conclusions which shows
11:36um well um large larger ID simulations
11:40has um um have the more accurate um can
11:46more accurately simulate the way
11:48breaking and is actually not necessarily
11:51um higher um uh computational um effort
11:56and uh um detached atti is has the
12:01lowest CPU cost actually. Um which also
12:05um can give people some guidance of how
12:08to use how to choose the proper
12:11turbulence models and this work also
12:13supported by Archer 2 um platform and
12:17also this work has been published on the
12:21uh OMA conference um this year. Uh so
12:27going further with this um convergence
12:30study confirmed and turbulence model
12:33confirmed we further trying to use this
12:36uh numerical model to study a more broad
12:39states and investigate how in the
12:44like um uh overall states how we
12:47breaking performs. So we have
12:50investigate based on the global wind
12:53farms and based on the 100 years um say
12:57state return level. Um what we are
13:00trying to do is to find um in the
13:06uh over uh many years um C return levels
13:11we want to we're trying to find uh uh a
13:16more consistent breaking boundaries with
13:18different state parameters as input and
13:22uh trying to um find the so in this
13:27figure we we are trying from the left
13:29picture um different say state
13:32parameters we're trying to um run a lot
13:36of short waves in the simulation on arro
13:39too and to um guide people how to choose
13:46um like the most severe breaking states
13:49to test on the uh wind offshore
13:53winterband foundations.
13:55Um so this is the result we currently
13:59got. We we got the the breaking profile
14:01over a broad state and we can predict
14:06the breaking timing um over those states
14:11we simulated and we found a very clear
14:13breaking boundary and can predict the
14:15breaking intensity over this um 50-year
14:19return period. Um so further we we have
14:23been we f we currently found the uh
14:27severe breaking cates and we have apply
14:29this um environmental conditions into
14:33our uh um breaking uh our um winterban
14:39models which uh has been conducted in
14:42the cost lab in Plymouth um last year
14:46and we are still in analyzing this um
14:50results and also trying to compare with
14:53our more complex more advanced um um
14:56open for models here which combine the
15:00um way breaking generation and also the
15:04floating um winterband motion. So this
15:09is my today's presentation. Uh
15:13and uh thanks thanks everyone for
15:16listening and please if you have some
15:18questions
15:20um
15:24thank you very much. Yes, if you have
15:26any questions I believe you could just
15:28unmute yourself and ask them or um there
15:30is a chat feature as well which you're
15:33very welcome to use.
15:35So, should I stop sharing my screen now
15:38or
15:40>> Yeah, you can go ahead and stop sharing.
15:43>> Yes.
15:43>> Thank you.
15:58Question.
16:00There's one in the chat. I'll read it
16:02out. Um so the question is when testing
16:05the different turbulence models did you
16:08redo your mesh convergence study?
16:11Um so I try to make the mesh consistent
16:15over different turbulence models and I
16:18have tested each model um whether it's
16:21sufficient to to
16:24simulate under this turbulence model
16:26because we know um like for example
16:29large ID models requires some higher
16:32mesh resolutions. So I have uh tried to
16:36satisfy the higher um requirement of the
16:40mesh.
16:41Um
16:43yeah. So the answer is yes. I I did um
16:47mesh convergence study for that and I
16:49actually I found so to try to accurately
16:52simulate wave breaking to capture the
16:55details of free surface. It's already
16:58satisfy the large ad models requirement.
17:05Hope I answer this question.
17:09>> Thank you.
17:13>> Okay, I don't see any hands up or any
17:15other questions. So, thank you again for
17:17your really great talk. That was very
17:19interesting. Uh shall we move on to our
17:22next speaker or is someone trying to
17:24speak? Sorry.
17:26>> Uh yeah, I just wanted to know what
17:27solver did you use for uh for your
17:30simulation?
17:32Yeah. So um uh we are using our inhouse
17:36solver inter um CCPWSI
17:40um form. Um but this the wave side is
17:43based on wave waveform.
17:54Thank you.
17:56Okay. Uh next speaker we have today is
18:00Johnny Casta uh who will be talking
18:02about their work around um crossplatform
18:05GPU implementation of open foam using
18:08only ISO C++ standard parallelism
18:12over to you.
18:15>> Uh okay hi thank you Lenora. Um
18:18yes I'm cast from the RC center. H this
18:22work has been done in collaboration with
18:24sedd at uh dar laboratory the university
18:28of exit and the people of the uh open
18:31form team which is used to be part of
18:35ESI but now is under kat
18:38um
18:42check
18:43yes okay so that's the outline uh
18:48shortly explain what I mean for a once
18:51in a life opportunity, how we did it, uh
18:54the current performance, the magic of
18:56empire, how to use it and what is left
18:59to do.
19:01Uh
19:03so why once in a life opportunity? The
19:08reason is the following. We've had a lot
19:10of porting uh of uh open form on GPU,
19:14many attempts since 2011.
19:18Um however none of this one in the end u
19:22merged into the main
19:26um I was at the past conference three
19:28years ago and I was talking with a guy
19:30from Nvidia and I said you know there is
19:33a problem if you do use something like
19:36CUDA or heap or the specific language uh
19:40you basically you put a lot of uh effort
19:43on the open form team to maintain it
19:46eventually is to understand and maintain
19:50um and the inductance. So what is the
19:53problem of the productivity?
19:55So um
19:59what I mean is uh if we look at the the
20:023P the productivity performance and
20:05portability
20:07many times especially when you have a a
20:10code so you don't have to scratch from
20:12uh you don't have to start from scratch
20:14but it's a code which is already there.
20:16uh the primary concern is the
20:19productivity and this um it means that
20:22if you rewrite everything in CUDA then
20:25your productivity is very low you will
20:28have a very high performance
20:30you will not have portability because
20:32it's uh only for Nvidia GPUs but uh you
20:35will suffer on the productivity
20:38um across the 3P for open form the
20:42primary concern is is justice it's just
20:45the productivity
20:46And um
20:49at the same time the C++ 17 introduced
20:53the parallel execution which is a
20:55portable framework with a decent uh
20:59performance.
21:00Um
21:02and uh if you just can find a way to the
21:06next slides.
21:11If you just want to know what is
21:13fundamentally you can write a loop with
21:15C++ uh a for loop as usual and then
21:18since C++ 17 you can offload it on GPU
21:22we using the so-called parent CD power
21:25execution so this is part of this ISO of
21:28the standard uh it been defined in the
21:3117 but it took a while to be implemented
21:33by compilers like the Nvidia compiler MD
21:36C++ or the MD compiler
21:39the MD client++ plus and there are two
21:42ports here which are around 2022 2023.
21:47So um while there is the need of porting
21:52open for GPU and if it does not happen
21:55in the next two three years it will lose
21:58a lot uh of impact because everybody's
22:01moving to other solvers. So while this
22:04one is really emerging at the same time
22:05it could not have done before because
22:07there was not this opportunity. So
22:10that's what I define as once in a life
22:12opportunity. This was really was the
22:14right time. The tools were there and
22:16that's what the um we we we tried to do.
22:22Now um how we did it? Well at the
22:26beginning we said okay let's start with
22:28the the typical the simplest case. So
22:31microform solver the cavity 3D. If
22:33you're familiar with open form you know
22:35this one very well. Um this one it
22:39contains the PCG solver which end up
22:42having a matrix multiplication vector
22:46and then there are some interpolation
22:48operation to port and then a fine volume
22:50operations. Now as we go through these
22:53that we we realize that we have to go
22:55forward and back into the different
22:58layers of the open form and we end up in
23:01a so-called spaghetti git repo. Um also
23:06because we had to try every time on
23:07different machines uh to make sure it
23:10was portable and so after a while we
23:12said you know what we have to
23:14fundamentally rewrite everything.
23:17uh but now we knew what to do and so we
23:19started from the primitives then
23:21containers then the fields and then so
23:23on moving higher and higher in the in
23:26the structure of the code uh with the
23:29idea that uh we have to monotonically
23:32increase the GPU loading capability. So
23:34what does it means every time we add
23:36something has to be expanding the GPU
23:39capability and not uh removing some of
23:41these uh without touching previous
23:45layers. This one made easier to debug
23:48expand and also to integrate into the
23:50CPU version. Uh to give you an idea of
23:55uh the low intrusivity of this approach,
23:58we counted so far around 200 parse sec
24:02uh instructions which are under the
24:05apply policy
24:07function
24:09and across the full code which is more
24:11than a million lines. So it's it's it's
24:13very low intrusive.
24:15Um I think we should redo three times as
24:18my uncle always used to tell me to do
24:20something right you should do three
24:21times but we did twice seems good enough
24:24for me. Um without going too much in the
24:28details for just that sake of time but I
24:31will uh explain there are three
24:33different levels of u intrusivity
24:37actually. So the first one is that the
24:40code is exactly the same for CPU and
24:42GPU. So basically if you take the code
24:45the CPU code you will look you will see
24:48that there are some sections which are
24:50just have the policy parent sec
24:53uh you need to find where it starts and
24:56finish the array. But apart of this then
24:59the body of the loop stays exactly the
25:01same. Great. This is exactly what the
25:04developers wanted because for them was
25:07easy to follow and and you know no not
25:09much to to think about. Uh however uh
25:14there are other situations where uh you
25:17create race conditions for example in
25:19the PCG. So for example when you have
25:21the residuals you will end up with um
25:25phase loop which tends to run on the
25:28same places. So you can't just do this
25:30one uh in in parallel. So you have
25:34different solutions to this problem. One
25:36is to use atomics but this means to have
25:38atomic containers which are um it
25:41requires a quite more uh
25:45changes into the code. Um or you could
25:49readjust the loop from per phase to per
25:54cell and that's the approach from rapid
25:56CFD.
25:58And then uh uh the last one is to say
26:00okay you know what if we wait for C++ 26
26:03when it's implemented this operation
26:05matrix vector for example will be
26:06already in the standard linear algebra
26:09and awfully also floated on the GPU. Now
26:12we could we don't have yet this. So we
26:14had we went for the rapid s approach
26:17which basically means to split um the
26:21the the
26:23product in three component the diagonal
26:26uh the lower and the upper parts
26:29and finally uh we have a third level
26:33level C where basically you can't
26:36rewrite the algorithm you just have to
26:37use a completely different algorithms
26:39like in the case of the smoother
26:42um where you do a polinomial
26:44approximation and which gets resolved in
26:47parallel.
26:49Now um if we look at the current
26:51performance what we tested was the
26:53cavity 3D the con of the future the
26:55motorbike test case and another
26:57automotive test case and uh with the
27:01solvers we did was the icform and the
27:02simple form preconditioners are the two
27:06steps calidel which is what the polom
27:08approximation gives you and the pcg and
27:11gmg and we tested on different hardware
27:16now uh instead Instead of splashing
27:18directly all these, I will try to go um
27:21one by one of what we're trying to do
27:23here. So first of all, uh we have a 32
27:27core uh for the cavity test case as a uh
27:31reference. So this is the CPU version 32
27:34MPI core. So 1 million 80 million 64
27:36million. uh when we say GG is uh
27:40basically the grace grace um the
27:43comparison with the grace grace which is
27:45the ARM CPU
27:47um which basically it says uh uh you
27:51don't offload on the GPU because there
27:53is none but there is a a CPU which has
27:56144 cores and it can mimic like the MPI
28:00uh communication is all embedded by the
28:04compiler and the targets when you
28:07compile is 3D power multiple the
28:10performance is slightly better but no
28:12much so nowhere excited uh but it's just
28:15because MPI the sorry the PCG doesn't
28:19scale well
28:21um when we went to the uh H100 so it was
28:27H100 with one MPI task from an Intel CPU
28:32we get a performance which goes up to 5x
28:36so to be happy and with the when we
28:40moved to oops I think I jumped on and
28:44when we went to the grayer we went up to
28:46eight times um and we were quite happy
28:50there as well. However, when we moved to
28:53the MI300A the performance dropped uh
28:57drastically and uh we were not really uh
29:00sure why. So we really um went back to
29:04the people uh from MD and we said the
29:08guys do you know what's wrong here and
29:10they say look try empire it's basically
29:13is this framework from liver um lower
29:17liver national laboratory which handles
29:19the memory pool so basically reserve
29:22some memory space for the what has to go
29:26on the GPU and it will really boost your
29:28performance
29:30well when we tried. We were super happy
29:33because the also the the MIA goes from
29:38um the
29:402x the two nearly eight times
29:45and when we go on the uh Gracehopper 200
29:50so we go up to 11x. So this means that
29:54this simulation on the gracehopper so
29:57one core one GPU goes 11 times faster
30:00than a 32 cores the base reference.
30:05Now when we go to the GMG we get even
30:08better performance uh as we move to
30:11bigger test cases. So this is 1 million
30:148,64
30:16uh and uh if you look well in the
30:19details we go up to 22 times which was
30:22this beyond the memory boundary. So
30:23something is strange it's too good and
30:25fundamentally what's happened here is
30:27that the number of iterations uh is
30:31changing and this is because uh when you
30:33switch from one MPI task to 32 NPI task
30:37there is a different uh elomeration
30:39which leads to more. So it's a positive
30:42result but is not just a speed up due to
30:45the GPU is also because the
30:49it uses less communication. So it's like
30:52if the GMG if you want it doesn't scale
30:54well. Now we are trying to understand a
30:56bit better how to improve that but um
30:59it's still it's is a is a pretty good
31:02we're quite happy with that. When we go
31:05to more realistic test case like the
31:08motorbike uh we got up to uh 3.5 uh
31:12nearly 4x for the large test case.
31:17um uh when we use the GMG as a solver we
31:21only twice. So here again we're trying
31:23to understand what's goes wrong and
31:25fundamentally is because there are many
31:27patches and and this one each of these
31:31one launches a small kernel and this one
31:33impacts on the on the performance. Now
31:37the solution is to group them and this
31:40is what the guy from open for are doing.
31:42So hopefully in the release in the next
31:44release will be solved this problem.
31:48Now how to use it? Um so the code is
31:52officially uh released. So you will find
31:55it in the news of the oper.
31:58Um it will appear as a branch at the
32:02moment and the reason is because uh uh
32:05if we release this one today it will
32:08have impacted all industrial customer.
32:11um which will be fine because you can
32:14switch off the GPU offloading but if
32:16there was something just wrong in one of
32:18those porting it will have impacted also
32:21then so so we need to go through the
32:22full test loop and we need to make sure
32:25that the guys from open CD are
32:30happy with everything that we did and
32:33and this actually is more on their side
32:35at this moment however the intention is
32:37to have one unique code by the next
32:40release which will be in December. So
32:42the 2012 will appear only with one
32:44branch or sorry only with one uh source.
32:50How you compile um so basically the form
32:54of load is what decide if you switch
32:56back to the CPU or you retain the those
33:00changes like the two gas cidell
33:02processor uh two gasell algorithm for
33:06the smoother. So this preprocessor flag
33:09is what uh switches between the two. Um
33:13and when you compile with MVC++ just say
33:16CDR GPU and uh you can specify how the
33:20memory is handled.
33:22uh if you use the target MI300 uh A or
33:27if it's just ND
33:30GPU you just have to put FIP CD power as
33:34a target and uh and uh in
33:39if you want to target a CPU you just put
33:42multiore in both cases.
33:45Um
33:47I think we just write on time. So
33:51if you want to have a go um remember to
33:54make sure you enable the HM so the
33:57memory uh management on the video this
34:00means to have one of the latest OS
34:02really compile and pile and you will see
34:06that it is in the third library party.
34:09So um and you will recognize because
34:11when compile open form it will tell you
34:12I found the library modify the
34:15preconditioner according those two that
34:17we tested so far and then export the
34:20memory the the form memory pool
34:23according to what is your architecture.
34:25I'm sorry this one is doesn't appear but
34:28fundamentally when I uploaded the slides
34:30I think there's been um a change in the
34:32slides which um upseted the layout.
34:37uh and then you just execute as a single
34:39core. So I perform you don't need to put
34:41MPI run because this will use one core
34:44much here.
34:46So what is left to do? Uh improve the
34:49performance for your indust merge into
34:52the CPU version 2612 that's will be the
34:55the the release where
34:57it will have everything that will appear
34:59in one source code. uh the multiGPU and
35:04uh port other parts of the solver like
35:06the turbulence models um and of course
35:10help is welcome. Um a big thank you to
35:13everybody. Um um I am the technical
35:16leader on this project but really who
35:18did the the job I mean the main
35:20developer is Mayan Kumar from SCD. So
35:22big thank you to to him and to the full
35:25team of the open form.
35:28>> Thank you. Uh any questions?
35:34>> Thank you very much. That was a really
35:36great talk. Uh sounds really exciting as
35:39well that you're uh nearly being sort of
35:41upstreamed into the main release. So
35:42that's really cool. Does anyone have any
35:44questions? Um we have time for a couple
35:47quick ones.
35:49Um, can we ask questions or just need to
35:53Okay, so I I was just raising my hand.
35:55Uh, thank you very much for your
35:57presentation. It was very interesting
35:59and uh very uh timely development in the
36:03open form community. We are industrial
36:06users of open form. uh one thing that I
36:10noticed is that you are uh basically
36:12comparing the cost of uh you are using a
36:19let's say not a high-end CPU as your
36:22base case. So um and then those uh B200
36:27GPUs that you're using obviously use
36:29much more power and they are much more
36:32expensive to rent.
36:34So it would be very interesting from a
36:38industrial point of view for for an
36:41industrial user who is going to pay for
36:44the compute uh time.
36:48How would it compare if you assumed
36:53that the power consumption of the CPU
36:57and GPU are the same or the prices are
36:59the same range basically because a 32
37:02core CPU is not comparable in terms of
37:05pricing and power consumption to a B200
37:10basically.
37:12>> Yeah, that's it's a very good question.
37:14Thanks. Um so let's say the best we got
37:17is 11x the best you could get out is
37:21around the the theoretical memory
37:23bandwidth. So if both code achieve a
37:27memory bandwidth saturation
37:30and so basically they're both memory
37:32bandwidth bounded um the the theoretical
37:37maximum you can get out is around is the
37:40ratio of the memory bandwidth right so
37:42which should be around 14 15x
37:46>> um say so
37:50the price between the grace software and
37:55and the and the CPU is probably around
37:5910 times. Okay. So, you're playing on
38:01the let's say around 10x is where you
38:04start to see the the gain.
38:07The power consumption is not so much uh
38:11difference as around between three and
38:144x.
38:15So, let's say the 10x should be your
38:18target. Okay.
38:21uh this is really if you just do the
38:24math uh about if it's worth to to to buy
38:28for it. However, you have another
38:30problem on this. Um the reason why we're
38:33moving to GPU is not really because we
38:36gain this huge acceleration because as
38:38you said is more expensive is
38:40fundamentally because AI is driving the
38:42market.
38:44AI is the the the big beast and HPC the
38:48business is much smaller compared to AI.
38:51So GPUs will be there because of AI and
38:55we have to find a way to to use them.
38:58>> So that's that's the way I will look at
39:01it. H for customers there will be there
39:05are things like AWS. There is things
39:08like the STC Maricumbo machine which is
39:10for industrial customer which offer a
39:13price which is more reasonable and less
39:17than the 10x that uh buying it will will
39:21do. And in any case you know you buy
39:23once but you know the real cost in the
39:27end is the power consumption of a
39:29supercomput. That's is the energy bit
39:34>> and yeah I mean do you have any plans to
39:37do such comparisons for example I think
39:40probably a B200 is equivalent to maybe
39:44a sirus node or something like that 288
39:47cores
39:52>> 5 600 watt so it would be interesting as
39:55if you for example use that as your base
39:58case and then
40:00that would instead of just uh
40:03computational speed up that gives you
40:06some commercial incentive really. So if
40:10you know what I mean.
40:10>> Yeah, I yeah know I I get your point. I
40:13agree. Yes, we we will do we will put
40:16but um uh as I said that we if you are
40:2011x and you're nearly the memory
40:23bandwidth ratio basically you can't get
40:25more than that.
40:26>> Yeah. And every code is moving to
40:29despite this every code is moving on GPU
40:33because as I said the is is is not HPC
40:37um
40:39>> the game. So
40:41um for scientific research definitely
40:46I I will say
40:48the more you can run on GPU the better
40:50is because that's what they will have
40:52>> and for industrial customer it will be
40:54really down to their um
40:58they will judge if if it will be
41:00convenient or not really in the end.
41:02>> Yeah. Okay. Thank you very much. Very
41:05interesting work and uh hope to be able
41:08to use this in future. Thank you.
41:10>> Yeah, thank you.
41:12>> Okay, thank you very much. I think we
41:14now need to move on to the next speaker
41:16because of um time. But um thank you
41:19Johnny. I think there's a question in
41:21the chat. If you could maybe type out a
41:24reply to that, that would be fab. But
41:25otherwise, I think there's lots of
41:26people. So please contact via email if
41:29you have any further questions.
41:31>> Thank you.
41:32>> Thanks. Okay. So our final speaker we is
41:36um Chanyang Xiao who will be presenting
41:38their work on numerical simulation of a
41:40floating offshore wind turbine at scale
41:43on arch 2 with open foam. Um so
41:47Chanyang, whenever you're ready to um
41:50present your slides, it's over to you.
41:53You have the floor.
41:58>> Hi. Can you hear me?
42:00>> Yeah.
42:01>> Can you see sharing right now? Yes, can
42:04see your slides.
42:05>> Okay, great. So, uh can I can start
42:08right now, right?
42:10>> Yes, please go for it.
42:11>> Okay, thank you Elena and hi everyone.
42:14Uh just a brief introduction about
42:15myself. My name is Tenyang and currently
42:18a postto in Oxford. So, I'm currently
42:21focusing on the uh numerical simulation
42:23of the floating offshore winter by kind
42:25of the like numerical uh framework. So
42:29we developed our framework based on open
42:31form and thanks to ashure 2 we got a lot
42:34of result just based on this
42:35computational resources and today I
42:38going to give introduction about our
42:41currently work about the uh about the
42:44floating off turban simulation uh on a 2
42:47using open form. So uh okay let's start
42:51it and that's some uh background and uh
42:54motivation just because uh for this uh
42:57floating off wind turbine it's quite
42:59it's quite uh like renewable energy
43:01quite essential for our current uh it's
43:05very um versatile and very uh important
43:09to our daily life and also for this
43:12coupling you know like for this uh we
43:14can say the wave structure interaction
43:16or floating or the uh flow structure
43:18structure interaction. The coupling of
43:20like hydrodnamics, aerodynamics and
43:23structure structure dynamics made this
43:25behaviors difficult to predict. And uh
43:30so um for the research method like we
43:33just develop based on the the the type
43:37of the the the solid part is it's a
43:40rigid or like the flexible. So for the
43:42rigid one like we it's kind of the
43:44framework we made it and uh like with
43:47motion solver everything is done but
43:49even for the uh for this rigid one we
43:51can in just totally inside of the open
43:54form. So uh that's the framework like
43:57that and uh then that's framework first
44:00of all and also we have this has been
44:03validated by using the like the use
44:06vibration case using the the different
44:08cross-section like circular uh cylinder
44:11and the square cylinder. So um another f
44:15another part is like about the
44:17turbulence model we used because you
44:19know sometimes for this uh flow
44:20structure interaction we have to take
44:22the uh turbulence uh into account for
44:25the flow part and here for this um like
44:30consider about the competitional cost
44:32and uh the industry application we
44:35choose lens for this uh case and uh
44:39initially uh for the standard uh komes
44:43or some other uh linear adabis cost
44:45model maybe some problem just because uh
44:48used to overpredicted the kinetic energy
44:51and uh so what we what I did here is
44:54like u do a do some modification about
44:57the traditional model like we use the
44:59lens lens scale correction actually this
45:02theory or this equation has been uh
45:05developed for a while but it's not
45:07available uh in open form so what I did
45:10is just I implemented this equation into
45:12open form and that's the first
45:15correction is like lens scale correction
45:17reduce the complex flows and another one
45:19is like the um because usually we use
45:23the for the turbulence model uh rest
45:25model we have the uh turbulent viscosity
45:28which use C mu to do some corrections
45:31and cu usually has been treated as the
45:33constant value for the linear one like
45:3609 and here we instead of using non the
45:40constant simu we just introduced
45:43the nonlinear version which can be used
45:45to reduce the turbulence viscosity in
45:47the region of high strength and this
45:50model has been tested combined with the
45:52previous uh framework we mentioned like
45:55that one uh by using this u vortex use
46:00vibration case of the flow of the rigid
46:02cylinder we can see the comparison of
46:04these three models especially for the
46:06nonlinear one we can see by introducing
46:09this nonlinear simu and
46:12lens correction term. We can capture
46:14more uh details about the uh about these
46:19vortices even like with same uh mash
46:23size match resolution
46:26and uh
46:29since sometimes our our like real
46:32application is not like just rigid part.
46:34So we just move forward move forward to
46:37uh for the develop the freework to
46:40support the uh flexible structure in uh
46:43for that one I mean purely open form
46:45doesn't support the like the structure
46:48dynamics calculation. So here what we
46:51did like using uh precise or actually we
46:54can use on any other uh coupling uh
46:57method maybe like uh parasive or some
47:00other library uh available and what does
47:04this uh library work is like try to do
47:08some communication between uh floy
47:10solver and solid solver. So like say
47:13here we do during each uh time step. You
47:15can actually do some custom
47:17customization based on your uh demand
47:20like here we just do the conversation
47:22like during each iteration or each time
47:25step like to read and write the
47:27displacement and force so and so forth.
47:31And for the solid solver here uh for the
47:33flid part actually has been uh similar
47:36to the previous uh framework for the
47:38solid structure. we use uh open form and
47:41dynam uh this oversight mesh. Well, for
47:44the solid part here uh we just use
47:46solids for form as a solid solver to to
47:49do the simulation and uh this has been
47:52tested like by using uh 2D and 3D case.
47:56So if you can say like u it's 2D beam
47:59and 3D flexible cylinder with long
48:02aspect ratio what we can say like by uh
48:06this first of all that this framework do
48:09supports this uh simulation like what we
48:11need and also by using this overset mesh
48:14we can to some extent like make sure the
48:18mesh quality
48:20if when it terms to the some high uh
48:23deformation happened for the mesh And uh
48:28apart from this framework we might just
48:31move on to the um wave structure
48:33interaction. I mean for this uh floating
48:35offshore wind turban case actually this
48:37case has done not only by me by our team
48:40like uh uh using the open form to
48:42develop develop a model like the right
48:45hand side is the the actual uh model one
48:49to seven scale uh we did like on
48:52Plymouth and the experiment has been
48:54done already for the simulation we
48:56developed the exactly same model just
49:00for the uh follow this scale to simulate
49:04the model. And if you can see here like
49:07uh we can we can we create the platform
49:11and the tower. Well, for the wind
49:13turbine, instead of using actual the
49:16physical wind uh turbine, we just here
49:18use a actuator line model sometimes we
49:22call it ALM to to simulate the wind
49:25turbine here. And uh for that case since
49:30it's very huge is 3D and we just ran
49:32this case in uh Archer 2 with uh 512
49:37calls like for around 24 hours uh for
49:39sorry for 42 hours got like some uh
49:42results like that and then since we got
49:46so many uh uh result we it's difficult
49:49to download at one go so we just use
49:52power view um which support to uh
49:55remotely visualize the data. We don't
49:57need to download all of them. And uh we
50:01can first check the result and then just
50:03download the part we need and do some uh
50:06further post-processing.
50:08And uh another part is like uh since if
50:11you can see like for the visualization
50:13for the visualization we uh uh the power
50:17view is still have some uh uh limitation
50:20just to show some details or like from
50:22different angles or some other uh
50:25rendering um function uh limitation. So
50:29what we did here like uh uh that's it
50:32has been done last year in Mr. Plymouth
50:34by one of the actually two students uh
50:37the internship. So what we did we
50:39provided the data we calculated uh by
50:42using uh open form on archer 2 and uh
50:45like the uh velocity field and the
50:48pressure field and some other data
50:50that's we were interested in gave them
50:53they use like uh the uh some unit unit
50:59unity this application actually for the
51:02uh game development so to visualize just
51:05for the post-processing to visualize the
51:07data
51:08Uh it's just like that we can just
51:10choose different angle and for from
51:13different view. uh here just shoot the
51:16uh vortex actually we can show some
51:18other data you we're interesting like
51:20from we can also uh take you to inside
51:24of the field to see some details and
51:26another thing is like this the reason we
51:28use unity here is like because it
51:30support uh to for the uh virtual reality
51:34headsets for like other equipment that
51:36means we can use another way instead of
51:38just seeing online uh or from the screen
51:41we can just use another way to to
51:43visualize this kind of data.
51:46Uh
51:48so uh when we talk about the oversight
51:51mesh uh here we just mentioned that one
51:53is just because we want to use that one
51:56to to say because currently for for that
52:00model we still use the dynamic mesh this
52:02moving mesh to to do the simulation. But
52:06you know like for the uh extreme
52:08condition maybe something going to
52:10happen to uh the mesh going to uh cannot
52:15use the like the standard moving mesh to
52:17accommodate this deformation. So one uh
52:21idea is like we might use this oversight
52:24mesh to do the simulation. So one
52:26possible uh things has been done like
52:28using you can see the floating object uh
52:31that's the multi-phase flow and also the
52:33wave structure interaction and then go
52:36on for this uh uh 3D floating offshore
52:39wind turbine we have created the
52:40oversight mesh just like that that means
52:43that for the uh blue one the mean the
52:47background mesh it doesn't move uh
52:48during the simulation the only um the
52:51component we call it oversight component
52:54going to uh move according enter the
52:56deformation or the any movement of the
52:59uh floating wind turbine to accommodate
53:02this deformation to make sure uh to the
53:04great extent to make sure the uh match
53:07quality then we can get some accurate
53:09result and uh the mash is like that well
53:13for the since we are still developing
53:15the the solver because currently we are
53:17using the solver uh inhouse code solver
53:19like code in inter CCP WSI form to
53:22support this uh deformation information
53:25this this floating offshore wind turbine
53:28simulation. So we have to to use this uh
53:31overset mesh we have to develop this
53:34over to support this uh this one. So
53:37it's still developing and hopefully we
53:39can get some results quickly uh on the
53:41arter 2.
53:45So uh here comes the con conclusions
53:48about so firstly the oversight mesh has
53:51been uh tested by using the uh rigid
53:54cylinder case and also for the flexible
53:57beam and the 3D flexible cylinder to see
54:00the uh the good quality um the mesh near
54:04the cylinder this good quality during
54:07move moving and another one is like uh
54:10the turbus model we used here is which
54:13uh means like for this flow structure
54:16interaction case. This R model with some
54:18like we call it advanced R model can be
54:21used to get some uh reasonable result
54:23and also for the deformable overset mesh
54:26which is developed to support this uh
54:29deformation of the structure going to be
54:31used for uh it has been tested. Well, it
54:34going to be used for the uh for the
54:37floating offshore wind turbine and also
54:39we say as we mentioned like uh
54:43uh we we
54:46try to use this open form precise solid
54:48solver to actually because we as me as I
54:51mentioned for the solid solver for the
54:53solid structure we don't use any uh
54:56third party solver to do the deformation
54:58calculation about the structure but in
55:00term to the uh deformation for for
55:02example the tower or the wind turbine
55:05blade we might need a solid solver to
55:07accomp to calculate the deformation or
55:09some other uh field we are interested
55:11in. So we might use the just ask why it
55:13did like precise to couple with another
55:16solid solver to to uh for this
55:20application and uh also in that
55:23situation because for the oversight mesh
55:24it might help to uh capture or to
55:28maintain the mesh quality and get some
55:30accuracy result but it going to be uh
55:33introduce an extra uh computitional
55:36demanding. So what we might do is like
55:38to just like uh Johnny mentioned like
55:40this uh AI techniques going to be
55:43helpful to speed up our simulation uh
55:47maybe can be integrated to our current
55:49framework to do the speed up
55:51acceleration sim simulation.
55:54Yeah, that's my uh uh presentation.
55:57Thank you for everyone.
56:01>> Thank you very much. Uh another great
56:03talk very interesting. Um and we do have
56:06yeah a couple of minutes left for
56:07questions.
56:11Uh I can see one in the chat. So what
56:14kind of interpolation scheme are you
56:16using for the overset mess mesh fringes
56:19and have you tested different ones seen
56:22effects of them on the results?
56:26>> Oh uh thank you Sebian that's good
56:28questions. So so far we just use the uh
56:32inverse distance scheme and uh since
56:35it's initially we want to see uh this
56:38framework like it's convergent works
56:41well and we might just uh try to use um
56:45because I think so far on the open form
56:47there's only three schemes available so
56:49we might just try because for the uh 2D
56:52simulation like the rigid cylinder
56:54oscillation I just tried both uh three
56:57different of them and it shoots like the
57:00inverse distance is more convergent and
57:02more uh accurate. So, but I mean for 3D
57:07we we'd like to try but currently we
57:09just use the inverse distance scheme by
57:12default. Yeah,
57:18>> thank you.
57:28Uh and another one uh saying hi very
57:30interesting talk. When using actuator
57:33line model can a correlation between
57:35waves and winds be considered and then
57:38what solid solver did you use?
57:44>> Okay. Okay. So the so uh I will just
57:46answer another one like for the solid
57:48solver currently uh we used if you
57:51mentioned like for the floating offshore
57:53wind turbine that's our uh the the
57:55in-house code like for the uh interform
57:59uh CCP WSI well for the one I used for
58:03to support the uh deformable oversight
58:05mesh because we have to use another uh
58:08third party solver actually I use solids
58:10for form uh this kind of solver to do
58:12some uh deformation calculation about
58:14the structure.
58:15Well, for this ALM uh
58:19so far uh
58:22I think uh we don't take the this
58:25correlation into account that's the win
58:27turban blade going to be gave the uh
58:30like it can be considered like
58:32prescribed motion. Yeah. Which having
58:34like this angle velocity like that.
58:43>> Okay. Thank you very much. Uh that
58:45brings us to the end of this webinar. So
58:48thank you again to our speakers and
58:50thank you to everyone for joining us
58:51today. Uh I hope you have a great rest
58:54of your day. Thank you and goodbye.

About this transcript

This page contains the full transcript of ARCHER2: HEC-WSI webinar by ARCHER2 HPC, generated from the public captions YouTube serves with the video. The transcript has 8,157 words across 1,166 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.