dataesr/scientific-paragraphs-categorization huggingface dataset:
0 m AMSL and + 3. 0 m AMSL were extracted from the survey datasets and their cross-shore position was correlated against beach volume from the monthly CPRG beach surveys. This contour was then used as a reference or proxy shoreline to which the SDW from each satellite image was translated to obtain a consistent shoreline estimate from each image. There are several ways of translating the SDW to the selected reference shoreline elevation (Z ref ), all of which require some knowledge of the profile morphology. Where adequate morphological data is available, it can be combined to derive a temporally averaged profile along each transect that can be used for determining the cross-shore distance between the estimated water level and the selected reference shoreline proxy (Fig. 5b ). Such datasets are rare, and in the majority of cases there is little to no information on beach profile shape.
At these sites, the SDW has to be translated using an estimated mean beach slope as shown in Fig. 5 (c ). Although the latter option makes for a poor representation of beach morphology, it is a parameter that can be obtained using empirical formulas based on sediment size distribution (e. g. ,  Flemming, 2011; Bujan et al. , 2019) , statistically based on existing extensive datasets (e. g. ,  Bujan et al. , 2019) , or even from EO data  (Vos et al. , 2020) , and can therefore be readily applicable to any site irrespective of the availability of measured data. Where the average beach profile was used (Fig. 5b ), S sat was determined by translating W sat by an amount equal to the horizontal distance (dx) as describe by (Eq. (  2 )): dx = S ̿ ref -X ̿ η (2) where dx is the horizontal distance by which W sat is translated to obtain S sat.
Assessment of best shoreline proxy A first step to assessing SDS accuracy and deriving shoreline time series from the SDW, is determining which shoreline proxy is the most relevant one at either site. We define this here as the elevation contour that best correlates with beach volume based on the quasi-monthly CPRG data sets (Fig. 8 ). Overall, the shoreline position is a weaker indicator of overall beach volume at Slapton than it is at Perranporth (Slapton: R max = 0. 61; Perranporth: R max = 0. 77). This is perhaps not surprising as, in addition to its typical rotational response, Slapton beach features one and sometimes two berms, the location of which change considerably and at very short timescales, resulting in a noisy shoreline signal. When considering the two extremities of the beach separately, agreement increases by 10% (south: R max = 0.
Shoreline change analysis Fig. 11  shows the time series of alongshore-averaged shoreline positions relative to the long-term mean derived from the entire satellite dataset  for Slapton using η t and Perranporth using η tsr (Fig. 11d ). SDS time-series for Slapton are shown for the entire beach (Fig. 11a ) the southwest section (Fig. 11b ), and the northeast section (Fig. 11c ). The corresponding average measured shoreline is also shown (S 0. 0 m ). Though the SDS signal is considerably noisier and does not consistently include an adequate number of images over the winter periods to capture seasonal variability, the results indicate strong intraannual cycles of shoreline change. The shoreline trends calculated over the survey period at the southwest section based on the satellite data are similar to those derived from the survey data (S η tsr = -1.
Overall, between 1984 and 1999 when L7 became operational, only 29 useable images were available none of which were captured over boreal winter months (December to March) compared to a total of 62 images obtained since 2015, of which 5 were captured in winter months. At Slapton on the other hand, satellite useability was markedly higher, particularly over the  pre-S2 era (84 images between 1984 and 1999; 119 between 2000 and 2014; 98 between 2015 and 2019). Though winter data at this site was not available for a third of the years up to 2013, at least three winter images were obtained every year since 2015. Consequently, limited data availability at both sites precludes the study of seasonal shoreline variability and may significantly influence long-term trends prior to 1999 at Perranporth, leading to questionable results.
It is therefore clear that the resulting SDS have been compromised, possibly due to cloud cover, atmospheric interference or local factors including the presence of a coastal lagoon despite the use of image compositing, a technique applied to overcome such effects. Furthermore, the dataset also features intermittent data (e. g. , only one data point between 1990 and 1997) rendering extracted trends along these transects questionable. These observations highlight the importance of SDS strategy (i. e. , water level definition, SDS translation method, and image filtering) for the derivation of reliable trends that enable improved future projections  (Castelle et al. , 2018; Turner et al. , 2021).
Acknowledgements This work was supported by  UK Natural Environment Research Council  grant ( NE/M004996/1  Masselink;  BLUE-coast  project). BC is funded by  Agence Nationale de la Recherche (ANR)  grant number  ANR-21-CE01-0015. Our thanks go to all the CPRG members and  University of Plymouth  students who have been, and still are, contributing their efforts to the CPRG beach survey program. We would also like to thank  Kilian Vos  and the  Water Research Laboratory  for developing and making freely available the CoastSat toolkit and for their support.
Data availability Satellite-derived data were obtained using CoastSat v1. 2 and are available at https://github. com/kvos/CoastSat. The data obtained using CoastSat and in-situ data used in this study can be found at ZENODO open access repository (doi:https://doi. org/10. 5281/zenodo. 7383895). The wave hindcast data used are included in the Copernicus Marine Environment Monitoring Service (CMEMS) NWSHEL-F_REANALYSIS_WAV_004_015 product can be found at https://marine. copernicus. eu/. Tidal elevation data are provided by the UK Hydrographic Office (UKHO) TotalTideTM v. 5. 0. 4. 9. 4 and are commercially available via https://www. admiralty. co. uk/.
INTRODUCTION Supercomputers expose massive parallelism by interconnecting a uniform set of parallel compute nodes. Each node is made of multiple sockets of multi-core processors embedding accelerators. As noted by  [1]  "It is therefore critical to find software solutions that can effectively exploit this scale of combined inter-node and intra-node parallelism". Ten years later, MPI and OpenMP are widely used in application codes on the largest supercomputers in the world. OpenMP has evolved to version 5. 2, and its version 4. 0 introduced dependent tasks to refine synchronization between tasks accessing the same (declared) memory region. Recent works  [2] [3] [4]  have provided solutions for interoperability issues when nesting MPI communications within OpenMP tasks  [5] [6] [7] , enabling the overlap of communications through OpenMP task scheduling.
MOTIVATION Let us introduce the motivation of our work through the LULESH case study. The Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics (LULESH) is a proxy application representing the computation kernel of hydro-simulations, originally provided by LLNL for co-designing towards exascale. As almost every CORAL benchmark, LULESH adopts the MPI+X programming paradigm: data are distributed among nodes of the supercomputer with MPI, and shared-memory parallelism is adressed with OpenMP parallel for loops. The application simulates on an unstructured mesh with 𝑂 (𝑠 3 ) nodes over 𝑖 time-step iterations. Parameters 𝑠 and 𝑖 can be passed through command line arguments. The simulation is a sequence of mesh-wide computational loops, MPI point-to-point communications with neighbors mesh connected through nodes, edges or faces, and an MPI collective communication reducing the dynamic time step at the end of each iterations.
Reference Parallel-for version The original LULESH code from LLNL uses a fork-join programming model. The computational loop sequences are parallelized with OpenMP parallel for construct and data are distributed with MPI communications outside of OpenMP constructs. The original code performances are rather poor as studied in  [17]. Therefore, we backported the global allocation of temporary work arrays optimization, which increases performances by 24% on our configuration and is compatible with reports constraints. Such a programming approach limits parallelism due to coarse synchronizations. Load balancing is limited per-loop, while iterations of separate loops could run in parallel independently. Additionally, the code expresses a rigid sequence of parallel computations due to barriers induced by OpenMP parallel-for loops semantic.
Task-based version To overcome the OpenMP parallel-for drawbacks, one might consider using dependent task-based programming models which can express a higher potential of asynchronous computation and communications, following the application data flow. 1. To fully respect the mentioned constraints, it relies on using the OpenMP depend clause on the taskloop construct  [18]  which is not standard yet. In addition, the code uses the inoutset dependence-type recently introduced in version 5. 1 of the OpenMP specification, which not yet available in production OpenMP compiler/runtime releases such as GCC, LLVM or ICC. Therefore, the code is relevant to very up-to-date OpenMP task based programming. Its structure is the following and shown on Listing 1. The entire application is wrapped into an OpenMP single region and replaces all parallel-for constructs with dependent tasks generated by taskloop.
TPL analysis. Coarse grain. The left-most point is the less inflated because LULESH is memory-bound by the DRAM bandwidth and having only 48 tasks per loop reduces the amount of parallel work and thus, memory contention. This can be seen on Fig. 2 (c ) where cores spend a lot of time idling due to low parallelism. In average, it leads to reducing DRAM contention and accelerating the work. Note that the overall execution time still ends up slower due to idleness. Middle grain. From 192 to 1,872 TPL, on Fig. 2 (d ) the work time deflates significantely from 40% inflation to 10%. Fig. 2 (e, f ) provide explanation: on this TPL range, we observe a reduction of L3 cache misses (L3CM) and stalled cycles due to cache-miss. Whenever a data access causes a L1DCM or a L2DCM, the memory controller will more likely find the data in the L3 memory without having to retrieve it from the DRAM.
Threads end up scheduling whatever is ready (in a breadth first manner) resulting in poor cache reusability. Overlapping TDG discovery with its execution has an impact on task scheduler that promotes data reuse: if the TDG discovery is too slow, the dataproducing task will never activate its successor as it has not been discovered yet. To measure the impact of the TDG discovery on its execution time, we run a complementary experiment blocking execution by threads until the TDG has been fully discovered. The MPC-OMP scheduler will have access to the description of all the dependencies before taking decisions. Table  1  shows the cumulated work and idle time on threads, the number of L2 data cache misses and L3 cache misses on different configurations. The instance with tag Normal corresponds to execution with TDG execution and discovery overlapping.
Summary In this section, we presented an in-depth analysis of the gains of a task based LULESH against the parallel-for reference version. Data reuses increase on high TPL value. We measure a minimal time and work time at TPL=1,872 which is much bigger than the number of cores  (24). The task-based version executes in 69𝑠 with MPC-OMP against 86𝑠 on the reference version using LLVM  16. Moreover, we also report that accelerating the TDG discovery on the task-based version would allow reaching finer task grain so accessed data fitting into the L2 cache level. It would also enable effective depth-first over breadth-first scheduling, and less idleness for a 40% gain on the parallel time.
Persistent Task Sub Graph (PTSG) LULESH is an iterative application onto an unstructured mesh. On each iteration, the same task dependences are rediscovered built upon mesh' nodes and elements. To accelerate the discovery  Implementation. On the first iteration, the runtime discovers the TDG just like before but internally marking tasks as persistent, so they are not destroyed on completion. It also creates every edge, as opposed to non-persistent mode which prunes edges to tasks already consumed, making the first iteration of persistent task graph discovery more costly. Creating every edge is necessary since no edges are recreated on future iterations, to ensure the correct order of execution with no race conditions. Then on future iterations, the producer thread only copies tasks firstprivate data such as the loop iterator variable.
The standardisation of persistent task dependency graphs raises multiple issues. A taskgraph  [24]  proposal was recently made. However, it does not provide fine control on task attributes: everything is assumed persistent. They also only provided specifications but no runtime implementations. In our implementation, we allowed the update of firstprivate data dynamically without invalidating the entire graph: Shared data, dependences or ICVs could also be updated for instance, and standardization is kept as future work. Applicability. The main performance gain we obtained from persistent graph is from dependency management. This is possible because our approach assumes dependences between tasks to remain constant over iterations. However, on simulation over unstructured meshes like LULESH, Adaptive Mesh Refinement (AMR) may occur during the simulation, slightly changing the mesh and so, the TDG.
Tile-based Cholesky Factorization Tile-based Cholesky dense matrix factorisation is a widely studied application of dependant task-based programming. We retrieved the version of  [6]  with dependent task and MPI communications performed by tasks. Optimizations (a), (b) and (c) does not provide any performance improvement/degradation as they are not reflected in the application: its dense dependency scheme is simpler than sparse and indirection-based data structures found in HPCG and LULESH. The optimization (p) provides performance gain on TDG when iteratively decomposing matrices of same dimensions and tile size. We evaluated the TDG discovery speed gain for a matrix of size 𝑛 = 65, 536 with block sizes 𝑏 = 512, distributed on 32 MPI processes of 24 cores over 16 Intel nodes, same one used in Section 2.
2, and believe it should be somehow adopted by production runtimes and standard specifications. Yet, refining tasks bellow 80𝜇𝑠 on HPCG will likely require new advances in parallel runtime system, as studied in ParSEC  [29]. MPI/OpenMP Interoperability. All our experiments are assuming the capacity of MPI and OpenMP to interoperate, i. e. automatically overlapping communication with computation from OpenMP task scheduler. This behavior is not granted by standards and many solutions exist  [2-4, 10, 25, 26]. The most portable currently is the OpenMP detach clause approach  [2, 10] , but the MPI counterpart has not yet been standardized, and users must adapt their code to perform the interoperability 'by-hand'. We believe automatic runtime interoperability is a more suitable solution. Porting Applications to task-based MPI + OpenMP.
Implementing standard and efficient task-based versions of LULESH and HPCG with MPI+OpenMP was challenging. Fine synchronizations through dependent tasks is error prone, and task dependences-aware debugger, profiler and visualization tools are needed but none exists for the standard hybridation understudy. Porting LULESH from its parallel for version to dependent OpenMP tasks, the original user code was extended from 3,000 LoC and 45 #pragma to 4,500 LoC and 72 #pragma for task grain and dependency management.
CONCLUSION AND FUTURE WORK The portable and efficient programming and execution of HPC scientific applications motivated the development of the two independent programming standards MPI and OpenMP. Recent task-based model of OpenMP provides new possible interactions with MPI. In this paper, we showed that the OpenMP Task Dependency Graph (TDG) discovery has an important impact on computational and communication performances. We showed that combining fine task grains and a depth-first scheduler improves the use of the memory hierarchy and communications overlap. It lead us to accelerate the TDG discovery with runtime and code optimizations, implementing a new persistent TDG extension into MPC-OMP compliant with scientific simulation code needs. Our results showed up to 2. 0x performances gain on LULESH weak-scaled to 16,000 cores against parallel for reference versions, and 1.
In this paper we describe how to improve communication time of MPI parallel applications with the use of a library that enables to monitor MPI applications and allows for introspection (the program itself can query the state of the monitoring system). Based on previous work, this library is able to see how collective communications are decomposed into point-to-point messages. It also features monitoring sessions that allow suspending and restarting the monitoring, limiting it to specific portions of the code. Experiments show that the monitoring overhead is very small and that the proposed features allow for dynamic and efficient rank reordering enabling up to 2-time reduction of communication parts of some program.
Introduction To cope with application requirements in terms of speed, precision or memory, the use of supercomputers has emerged as a dominant solution. To program parallel applications onto distributed memory systems, MPI (Message Passing Interface) is the de facto standard. MPI defines how distributed processes exchange data through point-to-point messages as well as collective or onesided communications. Being able to write parallel applications whose performance is close to the peak of the target machine is still a very difficult challenge. It requires to design an efficient parallel algorithm, to optimize data structure, to cope with load imbalance, etc. One of the main problems is the way data are exchanged, and allocated. This is of tremendous importance for the overall application performance as when an application (weakly) scales it spends more time in communication.
A reduce operation is, for instance, often implemented with an asymmetric tree of point-to-point sends/receives in which every process has a different role (i. e. , root, intermediary, and leaves). Known examples of stand-alone libraries using PMPI are DUMPI  [6]  and mpiP  [7]. EZtrace  [1]  is a tool for analyzing and monitoring MPI programs. These tools launches the MPI executable and capture all point-to-point communication in a set of files. Each file corresponds to a process and describes its communication behavior with the other processes. However, it only allows for post-mortem and static analysis of the trace. It is not possible for the MPI program to monitor itself and change its behavior at runtime according to the communication pattern. Similarly to PMPI-based tools, this approach has an API-level granularity, and is unconcerned with detailed information about collective calls.
PERUSE  [3]  takes a different approach, in that it allows the application to register callbacks that will be raised at critical moments in the point-to-point request lifetime. This method provides an opportunity to gather information on state-changes inside the MPI library and gain detailed insight on what type of data (i. e. , point-to-point or collectives) is exchanged between processes, as well as how and when. This technique has been used in  [3, 10]. In  [4] , a subset of the authors of this paper proposed a low-level MPI monitoring component for Open MPI  [5]. This paper presented the design and evaluation of a communication monitoring infrastructure developed in the Open MPI software stack and able to expose a dynamically configurable level of detail about the application communication patterns.
Background The proposed library is based on a monitoring interface  [4]. As presented above, this component was developed in Open MPI and used the MPI Tool Information Interface. The Open MPI Project  [5]  is a comprehensive implementation of the MPI 3. 1 standards  [13]  that was started in 2003, taking ideas from four earlier institutionally-based MPI implementations. It is developed and maintained by a consortium of academic, laboratory, and industry partners, and distributed under a modified BSD open source license. It supports a wide variety of CPU and network architectures that is used in the HPC systems. It is also the base for a number of vendors commercial MPI offerings, including Mellanox, Cisco, Fujitsu, Bull, and IBM. The Open MPI software is built on the Modular Component Architecture (MCA)  [14] , which allows for compile or runtime selection of the components used by the MPI library.
General Description The main interest of the MPI Monitoring Library is to provide a higherlevel interface by allowing the user to simply monitor its code and access the collected data. It mostly relies on low-level MPI Tool Information Interface features, mainly performance variables, that remain hidden to the user. The MPI Monitoring Library only defined one opaque datatype, MPI M msid (which stands for Monitoring Session IDentifier), that can only be used through the function of this library. They allow the user to create and act on monitoring sessions attached to a given communicator. While the session is active, the number and size of the messages exchanged between processors of the communicator are recorded and can later be obtained. Note that it also records communications that do not go through the communicator, as long as both processors belong to it.
Usage To properly use monitoring sessions, one should call MPI M init right after MPI Init and MPI M finalize right before MPI Finalize to set a proper environment. Then, create a different MPI M msid variable, automatically allocated, for each monitoring session wanted, in a scope that contains both the code to monitor and where the data need to be used. These sessions are completely independent from one another, therefore monitored portions of the code can overlap. Start the recording with MPI M start and stop it with MPI M suspend. If one wants to interrupt the monitoring session and then restart it, he can use MPI M suspend and MPI M continue, in this order. Once the monitoring is done, data can be obtained through multiple functions, it depends on how the data will be used. Sessions can be freed when the data they contain is no longer needed.
Common Example Here is an example to find out how MPI uses point-to-point communications to implement MPI Barrier. Note that this code is not fully complete as it does not check any return value, but it gives an idea on how this library can be used. Listing 2: Produces a file that described all point-to-point messages used to implement MPI Barrier Note that the only portion of the code that is being watched is between the calls to MPI M start and MPI M suspend, and this portion could possibly contain anything else.
Case with Several Collectives in a Program As said above, the MPI monitoring component sees collectives once they have been decomposed into point-to-point messages. However, it is not able to distinguish between different calls: the monitoring aggregates all the sent operation into the same MPI T variable. However, thanks to the sessions we are able to solve the problem of being able to distinguish which send operation belong to which collective. Indeed, it is sufficient to create one session per MPI call the programmer wants to distinguish (e. g. two different collective calls). In this case, the amount of data sent will be copied and stored in different buffers within the introspection library. As the library is designed such that the sessions can overlap or be nested, any kind of situations can be monitored thanks to the session mechanism.