•

•

  common Carp, target species, wide diet, burrowing behavior and ability to keep nutrients available for phytoplankton and macrophyte  Adults of Roach, wide diet, use entire water column  Only male of Perch, carnivorous diet, to limit fry, crayfish and tadepole Water pumps Macrophytes introduced : Watercress (Nasturtium officinale) Water lily (Nuphar lutea) Manna grass (Glyceria aquatic) Pickerel weed (Pondeteria cordata) • Experimentation lasted from March to December • Ponds were filled with water from the nearby watershed river, 3 weeks before the beginning and during the experiment to counteract evaporation • At stocking and harvesting fish were weighed and counted • Quantity of pellets was daily recorded and supplied on the basis of 2.8% live weight • Water quality : • Weekly, recorded for t°, pH, [O 2 ], %O 2 , water transparency, conductivity, • Monthly, analyzed for Nitrogen and Phosphorus compounds, • Chlorophyll : fluorometer analyzer (Phyto-PAM  ), • Nutrient budget for N and P Survival rate : survival rate similar between treatments, within each fish species • Feed Conversion Ratio value 16% lower for semi-

•

  P outputs > P inputs in every treatments • P quantity in outlet water > inlet water, in every treatments  role of senescence of plants? • Proportion of P input recovered in fish biomass gain >100%  a large part of phosphorus came from environment … sediments Conclusion Feed clearly improved fish production • In coupled treatment:  Phytoplankton development was limited to the benefit of Macrophytes  As a possible consequence, fish growth was limited too  Water concentration in N and P was buffered during the period observed  coupled treatment fish production compared to extensive treatment and improved water quality compared to semi-intensive treatment

Mass balance for P

		Extensive	Extensive	Semi-	Semi-	Coupled	Coupled	Coupled	Coupled
		1	2	intensive 1	intensive 2	1 fish	1 plants	2 fish	2 plants
	P inputs, g
	fish	27	19	38	39	38	0	38	0
	feed	0	0	151	151	151	0	151	0
	water	50	68	30	33	31	84	28	92
	P outputs, g
	fish	147	145	578	535	477	2	477	14
	Proportion of P
	input recovered in	241%	184%	297%	270%	166%	167%
	fish biomass gain
	water	66	98	135	91	136	137	24	119
	Unaccounted for	-137	-155	-493	-403	-447	-325

Context

• No treatment well balanced • But, in every treatments, N quantity in outlet water<inlet water,

• N input (from feed and water) was used more efficiently for fish biomass production in semi-intensive treatment  Feed seemed improving trophic web production but in a less extent in coupled treatment

Perspectives

• Further investigations need to be carried out to :

• well balance nutrient budget: sediments dynamic, macrophytes yield, gas emission

• Evaluate potential of coupled ponds to support biodiversity and to produce plants of market value Thank you


Clément Gavoille
email: clement.gavoille@cea.fr

Hugo Taboada
email: hugo.taboada@cea.fr

Patrick Carribault
email: patrick.carribault@cea.fr

Fabrice Dupros
email: fabrice.dupros@arm.fr

Brice Goglin
email: brice.goglin@inria.fr

Emmanuel Jeannot
email: emmanuel.jeannot@inria.fr

Relative performance projection on Arm architectures

Keywords: Performance Projection, Design space exploration, Arm architecture, Roofline model

With the advent of multi-many-core processors and hardware accelerators, choosing a specific architecture to renew a supercomputer can become very tedious. This decision process should consider the current and future parallel application needs and the design of the target software stack. It should also consider the single-core behavior of the application as it is one of the performance limitations in today's machines. In such a scheme, performance hints on the impact of some hardware and software stack modifications are mandatory to drive this choice. This paper proposes a workflow for performance projection based on execution on an actual processor and the application's behavior. This projection evaluates the performance variation from an existing core of a processor to a hypothetical one to drive the design choice. For this purpose, we characterize the maximum sustainable performance of the target machine and analyze the application using the software stack of the target machine. To validate this approach, we apply it to three applications of the CORAL benchmark suite: LULESH, MiniFE, and Quicksilver, using a single-core of two Arm-based architectures: Marvell ThunderX2 and Arm Neoverse N1. Finally, we follow this validation work with an example of design-space exploration around the SVE vector size, the choice of DDR4 and HBM2, and the software stack choice on A64FX on our applications with a pool of three source architectures: Arm Neoverse N1, Marvell ThunderX2, and Fujitsu A64FX.

Introduction

In the pursuit of reaching the exaflops target, the CPUs are becoming more complex both from hardware and software perspectives. Even when working on a multicore processor, it is essential to consider the single-core performance when exploring all the possibilities in its design. Indeed, there are multiple choices to make on the memory hierarchy side and the computational part with, for example, vector units. Therefore, it is meaningful to study the impact of those choices on the software stack and the applications. Considering we have access to a source machine and the software stack of a hypothetical target machine, how can we evaluate the impact of the differences between the machines and software stacks on the application performance?

This paper proposes a methodology to evaluate this impact of single-core performance from a source machine to a hypothetical target machine with a dedicated software stack. By analyzing the differences between two architectures and two binaries, this approach evaluates the performance from one machine to another with a roofline-based model, leading to an interval of performance. The obtained intervals analysis led to a study of the relevance of some hardware modifications and their impact on software. We present such an exploration around hardware vector sizes, various memory types, and different compilers on 3 Arm architectures (Marvell ThunderX2, Neoverse N1, and Fujitsu A64FX) and 3 CORAL mini-apps (Lulesh, MiniFE, and Quicksilver).

Section 2 presents the related work while Section 3 describes the methodology and its implementation. Then Section 4 presents the experimental environment used for approach validation in Section 5 and parameter exploration on 3 Arm architectures in Section 6.

Related Work

There are various approaches for evaluating the performance impact regarding design-space exploration. The first one relies on cycle-accurate simulators [START_REF] Kodama | Evaluation of the riken post-k processor simulator[END_REF] leading to precise prediction but significant overhead (10000×). This drawback is too limiting for exploring the performance impact on a whole mini-app.

Hence, analytical models can be used, leading to less precise but much faster estimation. The main difficulty lies in defining the relevant metrics and obtaining them. The choices and approximations made to obtain these metrics are different in each model and result in differences in precision and speed. Some analytical approaches choose to reduce the problem by being application-dependent [START_REF] Davis | Predictive analysis of a hydrodynamics application on large-scale cmp clusters[END_REF]. However, our model can explore different applications as we want to characterize diverse behavior in our applicative workload. Some of the applicationindependent approaches choose to use simulation on a small scale [START_REF] Obaida | Parallel application performance prediction using analysis based models and hpc simulations[END_REF] to have a good prediction and limit the analysis time compared to a complete simulation. Our approach does not rely on a simulator to get metrics but only on the emulation of non-native ISA, which is much faster than fully simulating the application. Furthermore, it allows exploring parameters on applications with a larger input size. While it is possible to consider a hardware-independent representation of the application [START_REF] Jongerius | Analytic processor model for fast design-space exploration[END_REF][START_REF] Jongerius | Analytic multi-core processor model for fast design-space exploration[END_REF], it is essential to look at the impact of software stack targeting an architecture in an environment as recent and diverse as the Arm HPC environment. The choices in the software stack have a non-negligible impact on performance, as shown on A64FX [START_REF] Domke | A64fx -your compiler you must decide![END_REF]. Therefore, our approach considers that having access to the target machine software stack is necessary for our model.

The idea of projecting the performance from a source machine to a target machine is behind some machine-learning-oriented approaches [START_REF] Ipek | An approach to performance prediction for parallel applications[END_REF]. One of the current limitations is the low number of machines in the Arm environment, making it hard to have a sufficient dataset necessary for training. However, we could consider coupling our approach with machine learning as more and more machines appear in the Arm HPC environment.

This article presents an analytical performance projection approach used for design space exploration. It allows to take into account the differences in hardware and in software stack when targeting a particular architecture. The exploration around different hardware parameters in this article leads to a discussion on the effectiveness and the limitations of the approach.

Workflow Presentation and Implementation

This section presents our approach and the methodology and its implementation for validation and design-space exploration. Figure 1 presents the main workflow in which the target and source machine characterization are represented in green and red while the model analysis running on the source machine is black. The first step is to get two binaries with the same source code: one with the software stack of the source machine and the other for the target architecture. Both binaries are then analyzed to gather the metrics directly on the source machine.

In the field of performance analysis, the Roofline model [START_REF] Williams | Roofline: An insightful visual performance model for multicore architectures[END_REF] is a well-known representation to characterize the behavior of an application according to the hardware limitations. So, we have chosen to use this representation to analyze performance on our source machine and evaluate a target one. The model output is a performance interval on the roofline representation of the target machine. Moreover, it helps to understand the impacts of the software stack on the target architecture.

Hardware and Software Characterization

Our approach relies on two binaries (source and target) obtained through a dedicated software stack. We consider the hardware differences thanks to the maximum available bandwidth and peak sustainable performance of the machine. In contrast, the differences brought by the software stack are visible in the metrics we obtain by analyzing the binaries. We have chosen to consider their Operational Intensities (OI) and their floating-point instruction mix. Once we have considered these hardware and software differences, we project the roofline analysis from the source machine to a hypothetical target architecture.

Hence, the first study is to obtain these hardware limitations imposed by the peak memory bandwidth of all memory levels and the peak sustainable performance of our core. These limitations are represented by the roofline (1) of the Stream Triad bandwidth of each memory level BW STREAM [START_REF] Mccalpin | Memory bandwidth and machine balance in high performance computers[END_REF] and the peak performance of High Performance Linpack (Perf HPL ) [START_REF] Petitet | Hpl -a portable implementation of the high-performance linpack benchmark for distributed-memory computers[END_REF]. This leads to two regions: (i) memory-bound limited by the memory bandwidth and (ii) computebound where the HPL peak performance represents the limit (see Figure 2).

roofline(OI) = min{BW STREAM × OI, Perf HPL } (1)
However, using HPL performance as a limitation is unrealistic because our applications do not have the floating-point instruction mix to reach that performance peak. Hence we have chosen to weigh this peak sustainable performance of a single-core following the equation ( 2) in which we compare the application floating-point operations per instruction to the maximum attainable on the machine which is only FMA-type of instructions on full vectors. With such a ponderation, the compute part of the roofline represents the maximum sustainable performance for our application instruction mix.

Perf HPL ponderated = Perf HPL 2 × vector size datasize × N floating point operations N floating point instructions (2)
The next main component in our model is the Operational Intensity (OI). Because we want to consider the bandwidth of the different memory levels, we need to assess the bytes accessed in these memory levels in the OI as presented in the Cache-Aware Roofline Model [START_REF] Ilic | Cache-aware roofline model: Upgrading the loft[END_REF]. Hence, in a two cache-level machine, we obtain the OI from L1 using the equation ( 3) with B i the total of bytes accessed in the cache level i.

OI L1 = N floating point operations B L1 + B L2 + B Main Memory (3)
The OI from the L1 memory level is the same OI defined in the CARM approach, and the OI of the main memory is the one used in the Original Roofline Model.

Fig. 2. Roofline representation: plain lines represent, from left to right, the rooflines of L1, L2, and Main Memory for each machine (green is source machine, red is target machine) with the peak sustainable performance obtained with HPL. The maximum attainable performance weighted by instruction mix is in dotted for both machines.

Performance Projection

The projection uses the same idea as Kwack et al. for roofline projection [START_REF] Kwack | Roofline analysis with cray performance analysis tools (craypat) and roofline-based performance projections for a future architecture[END_REF]: it considers the ratio between the performance (Perf source ) and one roofline on the source machine at the OI source (roofline source (OI source )), and projects this ratio on the target machine using the new OI and the new roofline (roofline target (OI target )). This is presented in equation ( 4). Thus depending on the OI value, the application is limited by the memory-level bandwidth or the core peak performance.

Perf target = Perf source roofline source (OI source ) × roofline target (OI target ) (4)
This analysis results in multiple values because of all the OIs and rooflines, forming a projection interval.

Methodology for Design-Space Exploration

We want to use this model to explore the parameters best reflected by this projection approach. We can make such an exploration around different software stacks and instruction mixes of the application. But we also consider hardware parameters such as the memory type and bandwidth and the hardware vector length. In the Arm environment, the exploration of the different vector sizes is allowed by the vector-length-agnostic approach of the SVE (Scalable Vector Extension) ISA of Arm architectures [17].

The model translates the hardware differences into rooflines used for projection, whereas the software stack and instruction mix changes are shown in the OI and its peak compute performance.

However, hardware and software changes are often not dissociated because one modification can impact the other. When we change the hardware vector size, we often observe a decrease in vectorization rate, affecting the instruction mix of the application.

Technically, when we consider a different vector size, we multiply the maximum performance obtained with HPL by new vector size old vector size and analyze the target binary again to see the impact this change has on the instruction mix and OI. When we consider different memory types, we do not need to run a new binary analysis as we only change the value of the main memory bandwidth and project performance with this new roofline, with this new value having the most significant impact on memory-bound applications. For example, when we introduce a HBM2 of A64FX on a DDR4 machine, we change the value of the main memory bandwidth to the one we measured on A64FX.

Hence, when running the model with each of the new parameters, we will obtain a different, or not, prediction interval. By comparing these intervals, we can analyze the impact of the evolution of diverse parameters and their impact on the performance of the application we study.

Implementation

As explained before, the machine characterization is obtained by running Stream and HPL on our source machine. We assume we have access to these benchmarks results or extrapolate this information on the source machine. For the analysis of the binaries we obtain with the different software stacks, we need to gather two kinds of metrics:

1. Instruction mix: number of floating-point instructions, total number of accessed bytes, number of flops. We rely on the dynamic code instrumentation with DynamoRIO [START_REF] Bruening | An infrastructure for adaptive dynamic optimization[END_REF] and ArmIE for SVE emulation [START_REF]Arm: Arm instruction emulator[END_REF] when changing the vector length. ArmIE instrumentation client allows for an easy floating-point instructions, FLOPs and bytes accessed count instruction per instruction, even for emulated SVE instructions on a non-SVE architecture. 2. Memory usage: percentage of hits in every memory level. We rely on hardware counters on the source machine but it is also possible to modelize a cache thanks to an ArmIE memory instruction trace client.

Our implementation is explained in Figure 3 adding precision to Figure 1 with the tool and benchmark used in our implementation.

Experimental Environment

This section describes the architectures and the benchmark applications used to validate and experiment our model.

Architectures

We chose to use three different Arm CPUs to experiment with our approach: a single-core of Marvell ThunderX2 (TX2), Arm Neoverse N1 (N1), and Fujitsu

A64FX (A64FX)

. Table 1 summarizes their characteristics and the results of HPL and Stream benchmarks running alone on a full node we obtained. These three architectures cover different parts of the Arm HPC environment, from the server market (N1 and TX2 processors) to the HPC focus (Fujitsu A64FX). The latter is currently the only Arm processor in production to use SVE vectors of 512 bits. With HBM2 and longer vectors than N1 and TX2, the single-core performance of a A64FX node is much higher when running STREAM and HPL benchmarks.

Applications

We use three benchmarks of the CORAL and CORAL-2 Benchmark suites: LULESH [START_REF] Karlin | Lulesh 2.0 updates and changes[END_REF] , MiniFE [START_REF] Barrett | The mantevo projectmini-applications: Vehicles for co-design[END_REF] and Quicksilver [START_REF] Richards | The arm scalable vector extension[END_REF].

LULESH (Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics) approximates hydrodynamic equations by using a regular cartesian mesh to partition the spatial problem. Our test's input is a mesh of size 100 3 .

MiniFE is a mini-application based on finite element methods that implement an iterative conjugate gradient solver. Our test's input is a mesh of size 256 3 .

Quicksilver is a CORAL-2 Benchmark suite mini-application that solves a simplified dynamic Monte-Carlo particle transport problem. Our input is the Coral 2 P1 1 input.

Model Validation

This Section validates the model using two close architectures (N1 and TX2) by ensuring that the target performance is in the predicted interval obtained by our workflow when using the same software stack (GCC). Figures 4 to 9 display the prediction interval obtained with the different projections. The blue crosses represent these projections creating the interval depicted by the blue dotted box. The source machine rooflines are green, and the target machine ones are red. We analyze each application after initialization and before finalization.

LULESH

Figures 4 and5 present the projection of LULESH from one machine to the other. The maximum sustainable performance weighted by the floating-point instruction mix (corresponding to the dotted rooflines) is a bit higher on TX2 than N1 despite having a lower maximum performance on HPL. The OIs of the L1 memory level are similar on both machines. Situated in the TX2 memorybound region, the differences between the bandwidth and the projections in this region create an interval that is not modified by the projections from the OIs of L2 and main memory. This interval is higher when projecting from TX2 because of the difference in L1 and L2 cache bandwidth. Because performances on both machines are nearly equal, we are closer to the TX2 roofline hence we obtain a better ratio which is then translated into a higher prediction interval. In both figures, the interval we predict includes the actual performance measured on the target machine, validating our approach in this application.

MiniFE

MiniFE exploits vectorization on the two architectures. This better vectorization rate is translated into a good performance of its instruction mix (see Figures 6 and7). Compared to LULESH, the OI of L1 is in the memory-bound region of all rooflines on both machines. Once again, the interval we predict, only being affected by the OI of L1, does not change whether we project from N1 or TX2. However, the N1 performance is higher (1.87 GFLOPS) than the TX2 performance (1.04 GFLOPS). Despite this difference in performance, our interval includes the measured performance. We can suppose that, because we are in the memory-bound region of the L1 and L2 cache levels, the better performance of MiniFE on N1 may result from the higher bandwidth of these levels.

Quicksilver

Quicksilver is our application with the lowest OI and measured performances on both machines (Figures 8 and9). The low performance may result from the poor vectorization rate of this application, shown in the maximum performance attainable by the instruction mix of both binaries. All the OI deducted from the L1 are in the memory-bound region of all rooflines, while the OIs derived from other memory levels are in the compute-bound regions. The prediction interval is obtained because of the OI from L1, which includes the measured performances. We observe higher performance on N1 (0.5 GFLOPS) than TX2 (0.4 GFLOPS). This difference in performance may be due to the difference in cache bandwidth, giving an advantage to the N1 core.

To conclude this validation, when we apply our model on the most similar machine in our machine pool, the prediction interval we obtain always includes the measured performance of our application. For the most memory-bound application (MiniFE and Quicksilver), we also observe higher performance when running on an N1 core that may be enabled by the higher bandwidth of the cache levels.

Exploration on different parameters

This section will use our approach to explore different hardware and software parameters. We have chosen to explore the different vector sizes allowed by SVE on all three machines. Hence, we compare the performance projection from a NEON machine (N1, TX2) to a hypothetical one with SVE with a vector size of 128, 256, 512, 1024, and 2048 bits. Another parameter we explore is the introduction of HBM2 for both DDR4 machines. Then, we combine these parameters to compare hypothetical SVE512 + HBM2 machines with A64FX. Finally, we observe the differences a change of software stack creates in exploring different vector sizes on A64FX. The SVE512 value is not a projection for A64FX in the following figures as it is native on this core.

Exploration on SVE vector sizes

One of the challenges in the design of future Arm core is the size imposed by the hardware on SVE vectors and the impact this choice has on the performance of the applications. We can obtain such a characterization with our model by looking at how such a change impacts the maximum performance imposed by hardware and the software stack. Figure 10 shows that the impact of the vector size on LULESH depends on the source machine. We observe that, when targeting A64FX and TX2 architecture, the binary's predicted performance benefits more from this increase in vector size than when targeting N1. GCC does not vectorize LULESH as much when targeting N1. Despite having a very similar source performance on native N1 and TX2, this difference in vectorization predicts lower performance on N1 than TX2 with longer SVE vectors.

When doing this exercise on MiniFE (Figure 11), we observe here a similar behavior on all machines. A change in vector size impacts all the predicted performances of our architectures. But this impact is not equivalent for all our architectures. When comparing TX2 and N1, the predicted interval upper bound of TX2 gains more performance at each step to reach a maximum of 10.2 GFLOPS.

The behavior of MiniFE when exploring vector size is opposed to Quicksilver (Figure 12). This application does not benefit from the change of vector size on any architectures. On all architectures, GCC cannot vectorize the application, meaning they do not benefit from this change of vector size. If we want to gain performance on Monte-Carlo applications, increasing the vector size is not the solution.

The predicted interval is smaller on A64FX than on the other two machines on all these figures. This shows that there are not many differences when projecting performances with different bandwidths of these machines. We can suppose it is because of the bandwidths of the A64FX being much higher, meaning the OIs of our application are closer to the compute-bound region for all bandwidths.

Exploration on the introduction of HBM2 on DDR4 machines

Another characterization we make with our approach is to analyze the introduction of the HBM2 memory of A64FX on N1 and TX2, creating a hypothetical machine with the same characteristics as our source machine with only the main memory bandwidth being different in our model. The first observation on Figures 13 and 14 is that the N1 core can be the one that benefits the most from this change of main memory bandwidth on LULESH and Quicksilver. This leads to a higher predicted upper bound on both applications on N1 despite LULESH having less performance with DDR4 on this machine. We suppose this is due to the N1 core having higher cache bandwidth and lower memory bandwidth than TX2. So the memory bandwidth gain is higher for the N1 core, leading to more performance gain for these applications. We also see that the lower bound of our predicted interval does not change on both applications compared to DDR4. This is due to the cache bandwidth of our hypothetical machine not being adapted to this main memory bandwidth increase. Finally, our model cannot characterize the latency aspect of our applications, which may be an issue with the introduction of HBM2 because of its latency access being higher than DDR4. We combine both changes of parameters we made in the two previous subsections to compare the introduction of SVE 512 bits and HBM2 on N1 and TX2 and compare it with the A64FX architecture on two applications: LULESH and Quicksilver. We choose to use GCC 10.3 on all 3 machines for this comparison presented in the Figures 15 and16. We can observe the change introduced by HBM2 to the interval predicted only with SVE512. Similarly, the use of HBM2 impacts the N1 core the most on LULESH, even with SVE512. Even if both machines can gain more performance, this leads to similar predicted performance between N1 and TX2 despite LULESH not benefitting from vectorization on N1. On MiniFE, the predicted performance is not as impacted on both applications. We only observe the predicted upper bound being higher by 0.6 GFLOPS on N1 and no change on TX2. This analysis shows it can be more impactful on performance to increase vector size than increasing the main memory bandwidth for MiniFE.

When we compare the projection on both applications to the performance on the A64FX machine, we predict performance to be higher on N1 and TX2 architecture. We can suppose the introduction of HBM2 and SVE512 on these machines changed their single-core roofline to be on par with A64FX, and GCC is more efficient when targeting N1 and TX2 architecture than A64FX, causing this higher predicted performance. We have seen that GCC has a hard time obtaining performance on a single-core of A64FX, and we want to compare it with the use of the Fujitsu Compiler (FCC). Figure 17 presents this comparison when changing the vector sizes on LULESH with GCC and FCC compilers. We do not have an interval with both software stacks, meaning the OIs of both binaries are in the compute-bound region of A64FX. However, we observe a different evolution of the predicted value when increasing the SVE vector size. GCC binary gains more performance when increasing vector size when compared to the FCC binary because it has more vector usage. Despite this difference in vectorization, we observe higher performance on FCC with SVE vectors from 128 bits to 512 bits, with the last being the native vector size. We can suppose that FCC is more careful when vectorizing the application because of its insight of the microarchitecture impact of the A64FX, whereas GCC vectorizes a loop without considering it as much. So we have better usage of an A64FX when compiling with the Fujitsu Compiler than with GCC.

Conclusion and Future Work

This article presents an approach for core design space exploration of a single processor core using performance projection from a source machine. We have chosen to consider the impact of the software stack of the target machine. The workflow relies on binary analysis, hardware characterization, and the Roofline model to obtain a performance interval on the target machine. Thanks to this projection, we can characterize the impact of the differences between a single core maximum performance, the bandwidth of all memory levels, and the cache efficiency. We can also analyze the differences brought by the software stack on the application with metrics such as the observed OI and maximum performance of the instruction mix with the use of the SIMD mechanism. Thanks to an implementation using emulation for dynamic code instrumentation, we have validated our model on a core of Marvell ThunderX2 and Arm Neoverse N1 architecture for three CORAL mini-apps: LULESH, MiniFE, and Quicksilver. We followed this validation work with an exploration around different SVE vector sizes and the introduction of HBM2 memory on DDR4 machines for the three CORAL applications. We used a pool of three different Arm core architectures for this exercise: ThunderX2, Neoverse N1, and A64FX. We also analyzed the impact of using different compilers (GCC and FCC) when exploring different SVE vector lengths on A64FX. To enhance the model, we plan to characterize some microarchitectural features and parallelism at a full-node level.

RIKEN Acknowledgment :

The work presented in this paper has been executed in the context of the CEA and RIKEN collaboration on High Performance Computing, Artificial Intelligence and Quantum Computing. We thank the RIKEN team for granting us access to the Fugaku supercomputer in the context of our bilateral collaboration.

Fig. 1 .

 1 Fig. 1. Our Performance-Estimation Workflow

Fig. 3 .

 3 Fig. 3. Description of the implementation flow.

Fig. 4 .

 4 Fig. 4. Results on LULESH TX2 → N1. Fig. 5. Results on LULESH N1 → TX2.

Fig. 6 . 7 .

 67 Fig. 6. Results miniFE TX2 → N1. Fig. 7. Results miniFE N1 → TX2.

Fig. 8 .

 8 Fig. 8. Results Quicksilver TX2 → N1. Fig. 9. Results Quicksilver N1 → TX2.

Fig. 10 .Fig. 11 .

 1011 Fig. 10. Exploration of different SVE vector sizes on LULESH Fig. 11. Exploration of different SVE vector sizes on MiniFE

Fig. 12 .Fig. 13 .

 1213 Fig. 12. Exploration of different SVE vector sizes on Quicksilver Fig. 13. Exploration of introduction of HBM2 on LULESH

Fig. 14 .Fig. 15 .

 1415 Fig. 14. Exploration of introduction of HBM2 on Quicksilver Fig. 15. Exploration of introduction of HBM2 and SVE512 on LULESH

Fig. 16 .

 16 Fig. 16. Exploration of introduction of HBM2 and SVE512 on MiniFE

Fig. 17 .

 17 Fig. 17. Vector sizes exploration with GCC and FCC on A64FX on LULESH

  Authors' contributions :Clément Gavoille: Conceptualization, Methodology, Software, Validation, Investigation, Writing -Original Draft, Writing -Review & Editing, Visualization Hugo Taboada: Conceptualization, Methodology, Resources, Writing -Original Draft, Supervision Patrick Carribault: Conceptualization, Methodology, Resources, Writing -Original Draft, Supervision Fabrice Dupros: Resources, Writing -Original Draft, Supervision. Brice Goglin: Conceptualization, Writing -Original Draft, Supervision. Emmanuel Jeannot: Conceptualization, Writing -Original Draft, Supervision.

Table 1 .

 1 Single-Core Characteristics the 3 Test Machines.

	Machine	TX2	N1	A64FX
	Performance (GFLOPS)	17.53	18.22	56.71
	MM bandwidth (GB/s)	25.43	21.14	65.52
	Vector Size and ISA	NEON 128 bits	NEON 128 bits	SVE 512 bits
	Memory Type	DDR4	DDR4	HBM2
	Compiler	g++ 10.3.0	g++ 10.3.0	g++ 10.3.0
				FCC 4.6.3
				(clang mode)
	Flags	-O3 -ffast-math

-O3 -ffast-math -O3 -ffast-math -mcpu=thunderx2t99 -mcpu=neoverse-n1 mcpu=a64fx


est destinée au dépôt

Managing religion at work: a necessary distinction between words and deeds. A multiple case study of the postures facing religious expression in French organizations

Hugo Gaillard

To cite this version:

  Hugo Gaillard. Managing religion at work: a necessary distinction between words and deeds. A multiple case study of the postures facing religious expression in French organizations. Employee Relations, 2022, 44 (4), pp.744-763. 10.1108/ER-02-2021-0053. hal-03501142

Author : Hugo Gaillard, Le Mans Université


A Laadhari
email: aymen.laadhari@imag.fr

C Misbah
email: cmisbah@ujf-grenoble.fr

P Saramito
email: pierre.saramito@imag.fr

On the equilibrium equation for a generalized biological membrane energy by using a shape optimization approach

Keywords: Vesicle shape, red cell membrane, Helfrich energy, shape optimization PACS:

A mechanical equilibrium equation of a vesicle membrane under a generalized elastic bending energy is obtained in this paper. Moreover, the derivation of this equilibrium equation bases on some shape optimization tools. This approach is new and more concise than the tensorial tools previously used for this problem.

Introduction

Phospholipid membranes are abundant in biology. They represent the major component of the cytoplasmic membrane of real cells. They are also present within the cell cytoplasm (e.g. Golgi apparatus, a complex assembly of phospholipid layers which serve to form small vesicles for protein transport). Phospholipid membranes are also used in many industrial application (e.g. giant liposome emulsions for cosmetics). Pure phospholipid vesicles (a closed membrane suspended in an aqueous solution) constitute an attractive model system in order to describe mechanical and viscoelastic behaviors of many cells, like red blood cells. They are also regraded as promising drug carriers for a delivery at specific sites in the organisms. This explains the increasing interest for biological membranes from various communities ranging from biology to applied mathematics. This contribution is concerned with a certain aspect of mathematical modeling of vesicles, or more generally of phospholipid membranes.

Vesicles are formed by amphiphilic molecules self-assembled in water to build bilayers, in a certain range of concentration and temperature. Many recent experimental and theoretical studies focus on the configuration and equilibrium shape of elastic biomembranes under flow (see [START_REF] Misbah | Vacillating breathing and tumbling of vesicles under shear flow[END_REF]) with the aim of understanding dynamics and rheology.

At room, as well as at the physiological temperature, the membrane is fluid (a two dimensional incompressible fluid). Due to incompressibility, the main mode of deformation of a vesicle is bending. A basic ingredient for biomembranes is thus bending energy. Helfrich [START_REF] Zhong-Can | Bending energy of vesicle membranes: general expressions for the first, second and third variation of the shape energy and applications to spheres and cylinders[END_REF] introduced a model in which the cost in bending energy is given by

α 2 Γ (H -H 0 ) 2 ds + β 2 Γ K ds,
where H = κ 1 + κ 2 is the mean curvature of the membrane surface, with κ 1 and κ 2 are the principle curvatures, K = κ 1 κ 2 is the Gauss curvature and H 0 represents the spontaneous curvature that describe the asymmetry effect of the membrane or its environment. The membrane surface is denoted by Γ while Ω represents the inside volume of the vesicle, such that Γ = ∂Ω. The integrals are performed along the membrane surface where ds denotes a surface area, while, in this paper, dx will represent a volume element. The constants α and β have the dimension of an energy and represent the bending rigidity and the Gaussian rigidity, respectively. The second term in the Helfrich model is a topological invariant by the virtue of the Gauss-Bonnet theorem that says if one is not interested in change of topology, then this contribution is a constant and can be ignored. We shall disregard in the energy the contribution coming from Gauss curvature, since we do not account for topological changes.

The equilibrium shape of vesicle membranes is determined by minimizing the bending energy subject to two constraints: fixed volume (incompressible enclosed fluid) and fixed area (inextensible membrane). It is a shape optimization problem that writes in the saddle point formulation as follows: find (Ω, ζ, p)

such that inf Ω⊂I R 3 sup ζ,p∈I R L(Ω, (ζ, p)),
where L is the Lagrangian

L(Ω, (ζ, p)) = Γ f (H) ds + ζ Γ ds -A 0 + p Ω dx -V 0 . (1)
The scalars ζ and p are Lagrange multipliers, and can be viewed as an effective surface tension and pressure difference, respectively. They enforce constant area A 0 and constant volume V 0 of the vesicle, respectively. The Helfrich energy has been generalized by introducing f , an arbitrary smooth function defined in I R.

Notice that the classical case corresponds to the choice f (H) = α 2 (H -H 0 ) 2 . The notion of saddle point can be intuitively understood as follows. We would like the energy to be minimal (or L to be minimal with respect to shape variation) and that at the same time L should behave with respect to ζ and p in a such a way to be maximum, so that to enforce constant volume and area (i.e. to suppress the terms proportional to ζ and p in L).

Since L is differentiable, any saddle-point (Ω, (ζ, p)) of L satisfies three conditions:

∂L ∂Ω (Ω, (ζ, p)) = 0, ∂L ∂ζ (Ω, (ζ, p)) = 0 and ∂L ∂p (Ω, (ζ, p)) = 0.
The two last conditions leads directly to the area and volume constraints, respectively. The aim of this paper is to show that the first condition, that involves the shape derivative ∂/∂Ω, leads to:

p + ζH + f (H)H + (2K -H 2 )f ′ (H) -∆ s (f ′ (H)) = 0. ( 2
)
Notice that the choice f (H) = α 2 (H -H 0 ) 2 leads to the classical equilibrium condition:

p + ζH + α 1 2 (H -H 0 )[4K -H(H + H 0 )] -∆ s H = 0. ( 3
)
where ∆ s is the surface Laplacian (known also as the Laplace-Beltrami operator), and will be defined explicity in this paper. The result (3) was first derived in [START_REF] Zhong-Can | Bending energy of vesicle membranes: general expressions for the first, second and third variation of the shape energy and applications to spheres and cylinders[END_REF], relation (31). Notice that these authors used the same notation H for -(κ 1 + κ 2 )/2, i.e. minus half of the present definition of the mean curvature

H = κ 1 + κ 2 .
In that paper use of several concepts of differential geometry were evoked (first and second fundamental forms) in order to arrive to the final result.

The main objective of this paper is to provide a derivation which is concise and self-contained. Our derivation uses quite simple and classical notions. While we will, in passing, quote some known expressions and Lemma in the mathematical literature, we shall provide their direct derivation here. In addition, our derivation can be made general without specifying the functional expression f (H). We shall discuss in the conclusion when generalized functionals can be expected to arise.

The paper is organized as follow: the second section introduces some notations and preliminary results while the third one aim at obtaining the equilibrium condition for the generalized expression (1) of the Helfrich energy. The paper is completed by a mathematical appendix.

Notations and preliminary results

All surface operators used in this paper are defined here. Let n denotes the unit outward normal vector to the shape Ω. Let f be any scalar function and v be any vector field. The surface gradient, the surface divergence and the Laplace-Beltrami operator are respectively expressed by: The boundary Γ is then parameterized by a level set function δ, defined, for all x ∈ I R 3 , as a signed distance (see Figure ( 1)):

∇ s f = (I -n ⊗ n) ∇f = ∇f -(n.∇f ) n, (4) ∇ s .v = (I -n ⊗ n) : ∇v = ∇.v -((∇v).n).n, ( 5
) ∆ s f = ∇ s . (∇ s f ) . (6)
δ(x) =    inf y∈Γ |y -x| when x / ∈ Ω, -inf y∈Γ |y -x| otherwise.
Then, the normal expresses as a gradient: n = ∇δ (since |∇δ| = 1.

Let us now express the mean and the Gauss curvatures. Let A = ∇ s n. Its characteristic polynom writes:

P A (λ) = det(A -λI) = -λ 3 + I 1 λ 2 -I 2 λ + det(A),
where I 1 = A ii and I 2 = (A ii A jj -A ij A ji )/2 (repeated indices convention is used), are two invariants; see below.

Let us first show that A = ∇ s n = ∇n. From the definition (4) of ∇ s , it is equivalent to show that n.∇n = 0. On the one hand, since |n| 2 = 1, we have ∇(n.n) = 0. On the other hand, by expansion we have ∇(n.n) = 2(n.∇)n + 2n ∧ rot(n). Then (n.∇)n = -2n ∧ rot(n). Next, since n = ∇δ, we have rot(n) = rot(∇δ) = 0. Finally n.∇n = 0 and then A = ∇n.

Moreover, from definition of A, it is also the Hessian of the level set function: A = (∇ ⊗ ∇)δ. Thus A is symmetric and admits three real eigenvalues. Since n.∇n = n.A = 0, A has a zero eigenvalue, associated to the eigenvector n. Let us denote κ 1 , κ 2 the two others eigenvalues of A. There exists an orthonormal eigenvector system (e 1 , e 2 , n) associated to (κ 1 , κ 2 , 0) such that A = κ 1 e 1 ⊗ e 1 + κ 2 e 2 ⊗ e 2 . By definition [3, p. 47], the values κ 1 and κ 2 are called the principle curvatures and the vectors e 1 and e 2 , the principle directions of curvature. The mean curvature and the Gauss curvature are, by definition H = κ 1 + κ 2 and K = κ 1 κ 2 , respectively. Notice that as coefficients of the characteristic polynom, they are invariant by any change of base, and thus in the eigensystem we find: I 1 = H and I 2 = K. Going back to the definition of I 1 and I 2 in terms of A = ∇n leads to the following expression of the mean and the Gauss curvatures:

H = ∇ s .n = ∇.n and 2K = H 2 -∇n : ∇n T . (7)
Notice that the use of the level set function δ enables us to extend the quantities n, H and K in the whole I R 3 space while their original definitions was introduced only on the surface Γ.

Obtaining the equilibrium equation

Let us denote by E(Ω), A(Ω, ζ) and V (Ω, p) the first, second and third terms of the right-hand side in (1), respectively. From Lemma A.1 derived in appendix A, we get:

∂V ∂Ω (Ω, p)(u) = p Γ u.n ds. (8)
Again, from Lemma A.1:

∂A ∂Ω (Ω, ζ)(u) = ζ Γ H u.n ds. ( 9
)
The rest of the paragraph deals with the E(Ω) term. From Lemma A.2 derived in the appendix, we obtain:

∂E ∂Ω (Ω)(u) = Γ ∂f (H) ∂Ω (Ω)(u) ds + Γ f (H)(Ω) H + ∂ (f (H)) (Ω) ∂n u.n ds, (10)
where ∂/∂n = n.∇ denotes the directional (or normal) derivative. The normal n, which also depends on the shape Ω is differentiable and its shape derivative in any direction u writes [START_REF] Simon | Differentiation with respect to the domain in boundary value problems[END_REF]: ∂n ∂Ω (Ω)(u) = -∇ s (u.n). This expression can be derived by considering the elementary local displacement u of the interface Γ. In such a case the level set function δ, that has the material derivative equal to zero, satisfies the transport equation in time t with the velocity v

dδ dt + ∇δ.v = 0 this leads to : dδ = -∇δ.u (11)
where dδ represents an elementary local displacement of the shape. The shape derivative of the normal is given by the Fréchet differentiation of ∇δ(x) |∇δ(x)| , in the direction dδ, since the propriety |∇δ(x)| = 1 for all position x in I R 3 , is not preserved if the displacement dδ is applied. Consequently, using (11), the shape derivative of n is given by

lim ε→0 n(δ + εdδ) -n(δ) ε = ∇(-u.∇δ) |∇δ| - [∇(-u.∇δ).∇δ] ∇δ |∇δ| 3 = -∇ s (u.n) (12)
Noting that, by considering the elementary local displacement dδ, we have |∇δ(x)| → 1 when ε → 0. This result can be shown otherwise (see [5, eq. A7]). From H = ∇.n, we obtain ∂H ∂Ω (Ω)(u) = -∇. [∇ s (u.n(Ω))] and then:

∂f (H) ∂Ω (Ω)(u) = f ′ (H) ∂H ∂Ω (Ω)(u) = -f ′ (∇.n) ∇.[∇ s (u.n)].
Next, (10) leads to:

∂E ∂Ω (Ω)(u) = Γ f (H)(Ω) H u.n ds+ Γ f ′ (H) ∂H ∂n u.n ds- T = - Γ ∇ s . (∇(f ′ (H))) u.n ds + Γ ∂(f ′ (H)) ∂n H u.n ds. (14)
Then (13) becomes:

∂E ∂Ω (Ω)(u) = Γ f (H) H + f ′ (H) ∂H ∂n + ∂(f ′ (H)) ∂n H -∇ s . [∇(f ′ (H))] u.n ds.
(15) This completes our derivation, in principle. However, some useful simplifications can be made, as shown below.

• Simplification 1. Using the summation of repeated indices convention, we have:

∂H ∂n = n.∇ (∇.n) = n i ∂ i ∂ j n j = ∂ j (n i ∂ i n j )-∂ i n j ∂ j n i = ∇. ((n.∇) n)-∇n : ∇n T .
Next, using expression (7) of the Gauss curvature K, we obtain:

∂H ∂n = 2K -H 2 + ∇. [(n.∇) n]
Finally, since n.∇n = 0 (see section 2) we get:

∂H ∂n = 2K -H 2 . (16)
• Simplification 2. From (4) we have:

-∇ s . {∇(f ′ (H))} = -∇ s . {∇ s (f ′ (H)) + (n.∇(f ′ (H))) n} = -∆ s (f ′ (H)) -(n.∇ s ) {n.∇(f ′ (H))} -(n.∇)(f ′ (H)) (∇.n).
Notice that, from definition (4) of ∇ s , we have n.∇ s = 0 and then:

-∇ s .(∇(f ′ (H))) = -∆ s (f ′ (H)) - ∂(f ′ (H)) ∂n H. (17)
Using the two simplifications ( 16) and (17), relation (15) becomes:

∂E ∂Ω (Ω)(u) = Γ f (H) H + f ′ (H) (2K -H 2 ) -∆ s (f ′ (H)) u.n ds.
Finally, using relation ( 8),( 9), the previous relation leads to:

∂L ∂Ω (Ω, (ζ, p))(u) = Γ f (H) H + f ′ (H) (2K -H 2 ) -∆ s (f ′ (H)) + p + ζ H u.n ds.
(18) This last expression leads directly to the equilibrium condition (2).

Conclusion

We have provided a new and self-contained derivation of the force for a biological membrane. We have extended the derivation to a generalized expression of the functional f (H). The Helfrich energy can be motivated by assuming that the stretching energy is of harmonic type (the energy is proportional to the square of change of distance from a certain configuration). In more complex situations, like red blood cells for example, this assumption is not obvious, in that a nonlinear constitutive law may constitute a better approximation. The resulting bending energy should thus lead to a different nonlinear function of mean curvature. While this is, intuitively, a quite plausible situation in real systems, we are not aware of any work who has dealt with this case yet.

Another, perhaps more frequent, situation is that where macromolecules (like proteins) interact with a membrane [START_REF] Divet | Fluctuations and instability of a biological membrane induced by interaction with macromolecules[END_REF]. The Helfrich energy α/2 Γ (H -H 0 ) 2 should be supplemented with a term of the form Γ F (c) where F is certain function of protein concentration. In addition, H 0 (the spontaneous curvature) is generally a c-dependent function (see [START_REF] Divet | Fluctuations and instability of a biological membrane induced by interaction with macromolecules[END_REF]). Minimisation of the full energy with respect to c yields a relation

F ′ (c) + α(H -H 0 )H ′ 0 (c) = 0
Solving for c yields, generically a nonlinear relation between c and H, and reporting the result into the original energy amounts to minimizing a generalized functional of the form Γ f (H), that is an expression of the form dealt with in this paper. This function is shape differentiable at Ω regarding Fréchet and, for any smooth function u, we have:

∂J ∂Ω (Ω)(u) = Γ ∂f ∂Ω (Ω) + u.n ∂f (Ω) ∂n + Hf (Ω) ds.
The next part is intended to give a simple derivation of the Murat-Simon expressions: Lemma A.1 and Lemma A.2, in the two dimensional case.

B. On a simple derivation of the above announced Lemma

Let us start with a two dimensional problem (the boundary is a line)

J(Ω) = Γ f (x)ds
ds is the curvilinear coordinate, and f is a function which does not depend explicitly on the form, but only on x which is a 2D vector field. Of course x is evaluated at the boundary, since the integral is along the boundary. We have ds = dα √ g, where α is a parametrization of a curve (for example if x(α)

is parametric representation of a curve, then g = x ′2 , where prime denotes differentiation with respect to argument). We can thus write

J(Ω) = Γ f (x) √ gdα
Since now integration is performed on the parameter α which does not depend on the curve (think of time parametrizing a trajectory!), the variation of J with the shape acquires the simple Euler-Lagrange derivative

R = ∂(f √ g) ∂x - d dα ∂(f √ g) ∂x ′ Expliciting R we have R = √ g ∂ ∂x f -f d dα ∂ ∂x ′ √ g - df dα ∂ √ g ∂x ′
We have ∂ √ g/∂x ′ = x ′ / √ g, d/dα( √ g) = x ′ .x ′′ / √ g, and d/dα(x ′ / √ g) = [x ′′ √ gx ′ (x ′ .x ′′ )/ √ g]/g. Using the result r ′ = √ gt (coming from the very definition of the tangent vector t), and t ′ = -Hn √ g, we easily find

R = √ g[Hf n -t ∂f ∂s + ∂f ∂x ]
Actually the force is defined as R/ √ g (see [START_REF] Kaoui | Lateral migration of a two-dimensional vesicle in unbounded poiseuille flow[END_REF]; in fact the above R is derivative with respect to shape at given α, while the physical force is to be defined at given s, and according to chain rule ∂/∂s = ∂/( √ g∂α)), and we can write finally the variation with respect to the shape

[Hf n + ∂f ∂n n]
since only the normal enters, this means that only normal motion matters. If u is displacement, the variation with respect to the form acquires the factor

Figure 1 :

 1 Figure1: Schematic view of the geometry. δ, the distance function, is positive for x outside Ω and negative inside. This is the signed distance.

Lemma A. 1 .

 1 Considering a smooth bounded open set Ω ∈ I R 3 and f (x) a smooth function defined in I R 3 . Define J vol (Ω) = Ω f (x) dx and J surf (Ω) = Γ f (x) ds. These two functions are shape differentiable at Ω and Hf ds, for any u smooth enough, where H is the mean curvature of Γ defined by H = ∇.ñ and ñ is the local extension of the normal n near Γ. Lemma A.2. (When the integrand depends on the shape). Let us consider a smooth bounded open set Ω ∈ I R 3 and f (Ω, x) a smooth function defined in I R 3 depending also on the domain. Define J(Ω) = Γ f (Ω) ds.

Γf ′ (H) ∇. [∇ s (u.n)] ds.(13) Let us denote by T the last term of the right-hand side. The classical Green formula leads to:T = -Γ f ′ (H) ∇. (∇ s (u.n)) ds = Γ ∇ s (u.n).∇(f ′ (H)) ds.Recall that, for any scalar function g and any vector field v defined over the closed surface Γ, we have the following identity (see appendix C):Γ ∇ s g.v ds = -Γ g ∇ s .v ds + Γ g v.n H ds.With g = u.n and v = ∇(f ′ (H)), we get:

u.n. This is the so-called Murrat-Simon expression (see Lemma A.1). We can reconsider that f depends on shape (actually on x ′ , x ′′ etc), we find trivially the generalized expression which contains derivative with respect to form (see Lemma A.2). Extension to 3D is elementary.C. Green formula with Surface operatorsThe Green formula with Surface operators is demonstrated in this appendix. Let any scalar function g and any vector field v defined over the closed surface Γ, n is the unit outward normal vector defined as a signed distance function like in the part 2. By (4), we haveΓ ∇ s g.vds = Γ ∇g.vds -Γ (∇g.n) (v.n) ds(19)By the green formula, using the fact that Γ is a closed surface, we haveΓ ∇g.vds = -Γ g∇.vds(20)Using (5), (20) givesΓ ∇g.vds = -Γ g∇ s .vds -Γ g (∇v.n) .nds(21)In order to simplify the second term in the right hand side of (19), we use the

A. Some shape optimization tools

The notion and basic tools of shape derivative [START_REF] Allaire | Minimum stress optimal design with the level set method[END_REF][START_REF] Simon | Differentiation with respect to the domain in boundary value problems[END_REF][START_REF] Murat | Quelques résultats sur le contrôle par un domaine géométrique[END_REF] is recalled in this appendix. Starting from a smooth reference open set Ω, with boundary Γ = ∂Ω, we consider domains of the type Ω u = (I + u)(Ω) with I denotes the identity in I R 3 and u is any sufficiently regular vector field.

Definition A.1. The shape derivative of J(Ω) versus Ω is defined as the Fréchet derivative at u = 0 of u → J ((I + u) (Ω)), i.e.

where J ′ (Ω) (u) is linear and continuous with respect to u and where . denotes the usual Euclidian norm in I R 3 . green formula

In ( 23), we can write successively