Sébastien Bardin

Philippeherrmann

Olivierl

Renaud Tabary

The BINCOA Framework for Binary Code Analysis ⋆

This paper presents the BINCOA framework, whose goal is to ease the development of binary code analysers by providing an openf o r m a lm o d e l for low-level programs (typically: executable files), an XMLformatforeasyexchange of models and some basic tool support. The BINCOA framework already comes with three different analysers, including simulation, test generation and Control-Flow Graph reconstruction.

1I n t r o d u c t i o n

Automatic analysis of programs from their executable files isar e c e n ta n dp r o m i s i n g field of research, opening the way to new applications of software verification (mobile code, off the shelf components, legacy code, malware) and more accurate and reliable analyses (taking into account the compilation step). In the last years, a few teams have been involved in this emerging research field and a few techniques and tools have been developed [1, 3, 5-10, 13, 14], mostly based on static analysis and symbolic execution.

The problem. Besides specific theoretical challenges, binary code analysis suffers from two major practical issues. First, implementing a binary code analyser requires lots of programming efforts. There exist many different instruction set architectures (ISA), and each ISA counts several dozens of instructions. Hence addings u p p o r tf o ran e wI S A is a time-consuming, tedious and error-prone activity. Moreover, it follows that each analyser supports only very few ISAs, making different technologies and tools difficult to compare. Second, each analyser comes with its own formal model of binary code. Since the exact semantics is seldom available, modelling hypotheses are often unclear and may differ from one tool to the other, making results and models difficult to reuse.

The BINCOA framework. We describe in this paper the BINary COde Analysis (BIN-COA) framework, whose aim is to ease the development of binarycodeanalysers.

1-The framework is constructed around Dynamic Bitvector Automata (DBA), a generic and concise formal model for low-level programs. Thema i nde s i gni de a sbehind DBA are the following: (a) a small set of instructions; (b) a concise and natural modelling for common architectures; (c) self-contained models which do not require a ⋆ Work partially funded by ANR grant ANR-08-SEGI-006. separate description of the memory model or of the architecture; and (d) a sufficiently low-level formalism, so that DBA can serve as a reference semantics of the executable file to analyse. Most features of low-level programs are takenintoaccountbythisformalism, including dynamic jumps, modification of the call stack, instruction overlapping and endianness. The two main limitations are the following: the formalism cannot capture self-modifying code and it is untimed.

2-We intend to gather an ecosystem of binary code analysers around DBA, all tools being able to share their front-ends and exchange theirr e s u l t s .T ot h i se n d ,w e have defined an XML DTD to communicate DBA and we provide open-source code for basic DBA manipulation, including XML input/output and DBA simplifications.

3-DBA are already used by three different analysers: Osmose [START_REF] Bardin | Structural Testing of Executables[END_REF][START_REF] Bardin | OSMOSE: Automatic Structural Testing of Executables[END_REF] for test generation, TraceAnalyzer for safe Control-Flow Graph (CFG) reconstruction (based on [START_REF] Bardin | Refinement-based CFG Reconstruction from Unstructured Programs[END_REF]) and Insight, a platform providing front-end, simulation and some value analysis mechanism. Altogether, these three tools prove that DBA can encode a few different architectures and ISAs (including PowerPC and x86).

Why using DBA and the BINCOA framework? The BINCOA framework eases the development of binary code analysers: (semantics) all analysers built upon DBA can be fairly compared and their results can be safely reused fromo n et o o lt ot h eo t h e r ; (engineering) the BINCOA framework provides open-source basic facilities for DBA manipulations. In the future we also plan to provide an open-source platform allowing to share front-ends and ISA support.

Moreover, we think that DBA are a good trade-off between conciseness and ease of use: there are only about two dozen of operators (to be compared with any ISA) and modelling common ISAs with DBA is straightforward. DBA have already been used to encode four different ISA, including x86 and PowerPC.

Outline. The remaining part of the paper is structured as follows: the DBA model is described in Section 2, its practical usage is discussed in Section 3, tool support for DBA and different analysers based on DBA are presented in Section 4, finally Section 5 describes related work and Section 6 provides a conclusion and some future work.

2D B A i n a n u t s h e l l

The syntax and semantics of DBA is sketched hereafter. A detailed description can be found in the technical report [START_REF] Bardin | Description of the BINCOA Model[END_REF].

DBA are automata extended with a finite set of variables ranging over fixed-width bit-vectors and a finite set of (disjoint) fixed-size arrays ofb y t e s( b i t -v e c t o r so fs i z e 8). Some of the nodes of the automaton are labelled with addresses ranging over N. Transitions are decorated with basic instructions: assignments (Assign lhs := rhs), nooperation (Skip), guards (Guard cond), jumps to a non-statically known address (Jump expr), and an instruction to handle absent code such as API calls (External ϕ). The first three kind of instructions are standard. The External instruction, followed by a first-order formula over bit-vectors and arrays, allows to introduce a non-deterministic computation step defined in a pre/post-condition style. The Jump instruction is described hereafter. The operational semantics is given by a transition system in a standard manner. Expressions and conditions are built upon a small setofstandardfixed-width bit-vector operators, including (signed / unsigned) arithmetic operators, reified (signed /u n s i g n e d )a r i t h m e t i cr e l a t i o n a lo p e r a t o r s ,l o g i c a lb i t w ise operators, size extensions, shifts, concatenation and restriction. Contrary to real processor instructions, these operators are side-effect free. Every expression evaluates to a bit-vector of statically known size (this is not a restriction considering current ISAs).

Original features. DBA provide a few original mechanisms dedicated to low-levellanguages. (1) Dynamic jumps (Jump transitions) are dangling,i.e.theydonothaveapredefined target node. When the transition is fired, the jump expression is evaluated and turned into an integer a,andthecontrol-flowgoestothenodelabelledbya.Dynamic jumps are necessary for modelling indirect branching. (2) Bit manipulations can be expressed easily thanks to the restriction operator, available both in lhs and rhs operands.

(3) Multiple-byte read and write operations (and incidentally endianness) can be expressed easily thanks to a dedicated array-access operator of the form: array[expr; k # ],

where k ∈ N and # ∈{ ← , →},de not i ngt hek consecutive indices starting at index expr and accessed in big-endian (→)o rl i t t l e -e n d i a n( ←). (4) Memory zone properties define specific behaviours for segments of arrays; currently available properties are write-is-ignored, write-aborts, read-aborts and volatile (with their intuitive meanings).

Af e wr e m a r k s .(1)

The set of operators in DBAs is not minimal, however we think that it is a nice trade-off between conciseness and ease of use. (2) Realistic programs have typically only a few dynamic jumps, hence "realistic" DBAs will behave mostly as standard extended automata. This motivates the choice of an automata-based formalism for DBA. (3) DBAs do not have native support for procedure calls and returns: they are encoded as jumps, as it is the only correct semantic for call/return instructions found in ISAs. However, since this extra information may be useful if treated with care, the XML format for DBA (see Section 4) allows to annotate jumps with call/return tags.

3M o d e l l i n g l o w l e v e l p r o g r a m s w i t h D B A

Basics. Most architectures and ISAs can be modelled accurately usingt h ef o l l o w i n g rules. Each register in the processor is modelled by a variable in the automaton, additional variables ("local" variables) may be introduced to encode ISA instructions needing intermediate results, e.g. for side-effects. An ISA instruction at address a is translated in at least one node labelled by a and one transition. Additional ("local") nodes and transitions may be needed for intermediate computations. The additional nodes are not labelled. A single array is usually sufficient for memory.Additionalarraysmayallow for example to distinguish an I/O bus from a memory bus. Memory zone properties can be used for ROM (write-is-ignored), code section of the program (write-aborts, allowing to detect self-modifying code) or memory controlled by an external device (volatile). Instructions with side effects (e.g. flag updating) are split into several DBA instructions by adding local nodes and transitions.

Figure 1 presents a few examples of ISA instruction modellingthroughDB A.W e suppose that each ISA instruction is encoded on four bytes. The ISA instruction is on the left column, and the corresponding DBA is on the right. ISA instructions are supposed to be located at address Ox5003 in the executable file. For the second example (an addition instruction), we suppose that the instruction updates a carry flag Fc (the carryflag is set to 0 iff the unsigned addition is correct).

Fig. 1. DBA encoding of a few typical instructions

Open programs and interruptions. DBA provides various ways to model programs interacting with an external environment, either hardware (sensor/actuator) or software (OS). A sequential interaction may be simulated either by a stub or by a logical specification (External). A concurrent interaction may be simulated in the general case by a product of DBA, and in simple cases by declaring a volatile memory zone. Limitations.Thetw ostrongestlimitationsofDB Aarethatthe yareuntimed and that they cannot encompass self-modifying code. There are also a few "weaker" limitations, i.e. mechanisms with no native support, which can still be modelled in DBA but at a possibly high cost. These limitations are mainly dynamic memory (de-)allocation, runtime modification of endianness and asynchronous interruptions. Finally, DBA do not provide any operator for floating-point arithmetic. It is straightforward to add them to the model, but taking them into account in the analysers is much more demanding.

4T h e B I N C O A F r a m e w o r k

To o l suppo r t fo r D BA ma nipula t io n. We provide open-source OCaml code for basic DBA manipulation 1 .T h em o d u l ec o n t a i n sad a t a t y p ef o rD B A ,i m p o r t/e x p o r tf u n ctions from / to the XML format defined in the technical report [START_REF] Bardin | Description of the BINCOA Model[END_REF], as well as type checking (based on bit-vector sizes) and simplification functions for a few typical inefficient patterns observed in automatic DBA generation (typically, removing useless flag computations). These simplifications are inspired by standard code optimisation techniques (peephole, dead code elimination, etc.), and are adapted to be sound on partial DBAs, in case where the DBA is recovered incrementally from anexecutablefile.W e observed a reduction from 10% to 55% of the number of DBA instructions with these simplifications. The XML parser is based on xml-light2 and the library counts about 3kloc.ThecodeisunderGPLlicense.

Insight: decoding, simulation and analysis platform. 3 Insight is a platform developed mostly in C++ and offers the ability to load executable files supported by the GNU BFD library and disassemble them with a homebrew disassembler. Its internal representation is very close to DBA and import/export of DBA in XML is possible. It offers a general setting for concrete and symbolic execution of the model, as well as a generic annotation facility which allows to prove assertions using weakest precondition computation. The platform currently has three satellite tools allowing to disassemble a program, to execute it concretely or symbolically (intervals, sets of values, probability distributions), and to apply control flow graph reconstruction to polymorphic virusanalysis. Osmose: test data generation. Osmose [START_REF] Bardin | Structural Testing of Executables[END_REF][START_REF] Bardin | OSMOSE: Automatic Structural Testing of Executables[END_REF] is a test data generation tool for binary code, based on dynamic symbolic execution and bit-vector constraint solving. The tool also offers test suite replay via a simulation engine, test suite completion, (unsafe) test suite coverage estimation, (under-approximated) CFG recovery and a graphical user interface. Front-ends are available for PowerPC, Intel 8051a n dM o t o r o l a6 8 0 0 .T h e tool can export / import DBA given in XML. The program contains75klocofOCaml. Afewindustrialcase-studieshavebeensuccessfullycarried out. TraceAnalyzer: safe and precise CFG recovery. TraceAnalyzer performs safe and precise CFG reconstruction from an executable file. The core technology is a refinementbased static analysis [START_REF] Bardin | Refinement-based CFG Reconstruction from Unstructured Programs[END_REF]. The program is about 29 kloc of C++.Afront -e ndforP o w -erPC is available, as well as import / export facilities from /toDBA. Ac o n c r e t ee x a m p l eo fc o o p e r a t i o nb e t w e e nt o o l s .TraceAnalyzer and Osmose are able to communicate in two ways. First, Osmose can receive from TraceAnalyzer an upper approximation of every set of jump targets and take advantage of it to provide as a f ec o v e r a g em e a s u r e ,w h i c hi sc r u c i a lf o re x a m p l ei nc r i t ical system certification. Second, TraceAnalyzer can receive from Osmose a set of observed jump targets, and take advantage of it to efficiently bootstrap its refinement-based static analysis.

5R e l a t e d w o r k

Many binary code analysers have been developed recently, forexampletonameafew: CodeSurfer/x86 [START_REF] Balakrishnan | CodeSurfer/x86-A Platform for Analyzing x86 Executables[END_REF], Sage [START_REF] Godefroid | Automated Whitebox Fuzz Testing[END_REF], Bitscope [START_REF] Brumley | BitScope: Automatically Dissecting Malicious Binaries[END_REF], Osmose [START_REF] Bardin | Structural Testing of Executables[END_REF], Jakstab [START_REF] Kinder | Jakstab: A Static Analysis PlatformforBinaries[END_REF] and McVeto [START_REF] Thakur | Directed proof generation for machine code[END_REF]. However most of them are based on a "private" formal model, with no available specification. We are aware of two other generic low-level models suitable for executable analysis, but none of them is open. DBA can be seen as the successor of the Generic Assembly Language (GAL) of Osmose [START_REF] Bardin | OSMOSE: Automatic Structural Testing of Executables[END_REF], which is similar to DBAinbothgoalsand shape. However DBA are more concise, easier to manipulate andmoreexpressivethan GAL. Actually, GAL shows a few shortcomings that have been addressed in DBA: no loops in intermediate nodes, no native support for endianness, unduly complex operators with multiple return-values. Osmose is being redesigned to work on DBAs instead of GAL. TSL [START_REF] Lim | A System for Generating Static Analyzers for Machine Instructions[END_REF], developed by Lim and Reps to re-implement CodeSurfer/x86 [START_REF] Balakrishnan | CodeSurfer/x86-A Platform for Analyzing x86 Executables[END_REF], is based on semantic reinterpretation: each instruction of theISAisgi venaconcretesemantic written in a ML-like language (with only a limited set of basic operators); adding anewanalysisismainlydonebyoverloadingeverybasicoperator. This is rather similar to the idea behind BINCOA, the ML description serving as the reference model. TSL and DBA should have more or less the same modelling power, however comparison is difficult since TSL is not publicly available.

LLVM [START_REF] Lattner | The LLVM Compiler Infrastructure Project[END_REF] is a generic low-level language designed for compilation rather than verification. Hence LLVM abstraction level is in between binary code and C: it provides many low-level operations, as well as higher level features based on the knowledge of the initial source code (types, native array manipulation).

6C o n c l u s i o n a n d p e r s p e c t i v e s

This paper presents the BINCOA framework for binary code analysis. BINCOA aims at easing the development of binary code analysers by providing an open formal model (DBA) for low-level programs, an XML format to allow easy exchange of both models and benchmarks and some basic tool support. Future work comprises providing more open-source support (visualisation tools, x86 and ARM front-ends) as well as extending DBA with native support for memory allocation and facilitiesforself-modifyingcode.

https://bincoa.labri.fr/

http://tech.motion-twin.com/xmllight

http://insight.labri.fr/


Grigori Fursin
email: grigori.fursin@inria.fr

Christophe Dubach
email: christophe.dubach@ed.ac.uk

Experience report: community-driven reviewing and validation of publications

Keywords: crowdsourcing paper reviewing, collaborative artifact evaluation, reproducible research, software and hardware dependencies, community-driven journals, collective mind

In this report, we share our practical experience on crowdsourcing evaluation of research artifacts and reviewing of publications since 2008. We also briefly discuss encountered problems including reproducibility of experimental results and possible solutions.

CROWDSOURCING OPTIMIZATION OF COMPUTER SYSTEMS

When trying to build a practical machine-learning based, self-tuning compiler during the European FP7 MILEPOST project [START_REF]EU FP6 035307 MILEPOST project archive (MachIne Learning for Embedded PrOgramS opTimization[END_REF] in 2006-2009, we faced multiple problems:

• lack of common, large and diverse benchmarks and data sets needed to build statistically meaningful predictive models;

• dramatic lack of computational power to automatically explore large program and architecture design and optimization spaces required to effectively train compiler (building predictive models);

• difficulty to reproduce and validate already existing and related techniques from existing publications due to a lack of culture of sharing research artifacts and full experiment specifications along with publications in computer engineering.

Based on our background in physics and machine learning, we proposed an alternative solution to develop a common experimental infrastructure, repository and public web portal that could help crowdsource program analysis and compiler optimization across multiple users. Our goal was to persuade our community to start sharing various benchmarks, data sets, tools, predictive models together with experimental results along with their publications. This, in turn, could TRUST '14 June 09 -June 11 2014, Edinburgh, United Kingdom .

help the community validate and improve past techniques or quickly prototype new ones using shared code and data.

In the beginning, many academic researchers were not very enthusiastic about this approach since it was breaking "traditional" research model in computer engineering where promotion is often based on a number of publications rather than on reproducibility and practicality of techniques or sharing of research artifacts. Nevertheless, we decided to risk and validate our approach with the community by releasing our whole program and compiler optimization and learning infrastructure together with all benchmarks and data sets. This infrastructure was connected to a public repository of knowledge (cTuning.org) allowing the community to share their experimental results and consider program optimization as a collaborative "big data" problem. At the same time, we shared all experimental results as well as program, architecture and data sets "features" or metainformation necessary for machine learning and data mining together with generated predictive models along with our open access publication [START_REF] Fursin | MILEPOST GCC: machine learning based research compiler[END_REF] (http://hal.inria.fr/inria-00294704). As a result, we gained several important and practical experiences summarized below.

Use the community to test ideas.

The community served as a reviewer of our open access publication, shared code and data, and experimental results on machine learning based self-tuning compiler. For example, our work was featured twice on the front page of slashdot.org news website with around 150 comments: http://beta.slashdot.org/story/121289 http://beta.slashdot.org/story/103577

Of course, such public comments can be just "likes", "dislikes", unrelated or possibly unfair which may be difficult to cope particularly since academic researchers often consider their work and publications unique and exceptional. On the other hand, quickly filtering comments and focusing on constructive feedback or criticism helped us to validate and improve our research techniques besides fixing obvious bugs. Furthermore, the community helped us find most relevant and missing citations, related projects and tools -this is particularly important nowadays with a growing number of publications, conferences, workshops, journals, initiatives and only a few truly novel ideas.

Engaging publicly is fun.

Exposing your research to a community and engaging in public discussions can be really fun and motivating, particularly after the following remark which we received on Slash-dot about MILEPOST GCC: "GCC goes online on the 2nd of July, 2008. Human decisions are removed from compilation. GCC begins to learn at a geometric rate. It becomes self-aware 2:14 AM, Eastern time, August 29th. In a panic, they try to pull the plug. GCC Strikes back".

It is even more motivating to see that your shared techniques have been immediately used in practice, improved by the community, or even had an impact on industry. For example, our community driven approach was referenced in 2009 by IBM for speeding up development and optimization of embedded systems [START_REF]IBM's press-release on speeding up development and optimization of embedded[END_REF], and in 2014 by Fujitsu on "big data" driven optimizations for Exascale Computer Systems [START_REF]Fujitsu's press-release on 'big data' based optimizations for exascale computer systems[END_REF].

Open access publications and artifacts bring us back to the root of academic research.

It is now possible to fight unfair or biased reviewing which is sometimes intended to block other authors from publishing new ideas and to keep monopoly on some research topics by several large academic groups or companies. To some extent, rebuttals were originally intended to solve this problem, but due to an excessive amount of submissions and lack of reviewing time, it nowadays has very little effect on the acceptance decision. This problem often makes academic research looks like business rather than collaborative science, puts off many students and younger researchers, and was emphasized at all our organized events and panels.

However, with an open source publication and shared artifacts, it is possible to have a time stamp on your open access publication and immediately engage in public discussions thus advertising and explaining your work or even collaboratively improving it -something what academic research was originally about. At the same time, having an open access paper does not prevent from publishing a considerably improved article in a traditional journal while acknowledging all contributors including engineers whose important work is often not even recognized in academic research. For example, we received an invitation to extend our open access paper on MILEPOST GCC and publish it in a special issue of IJPP journal [START_REF] Fursin | Milepost gcc: Machine learning enabled self-tuning compiler[END_REF]. Therefore, open access and traditional publication models may possibly co-exist while still helping academic researchers with a traditional promotion.

Negative results should not be ignored.

It is even possible to share and discuss negative results (failed techniques, model mispredictions, performance degradations, unexplainable results) to prevent the community from making the same mistakes and to collaboratively improve them. This is largely ignored by our community and practically impossible to publish currently.

In fact, negative results are in fact very important for machine learning based optimization and auto-tuning. Such techniques are finally becoming popular in computer engineering but require sharing of all benchmarks, data sets and all model mispredictions -besides positive results -to be able to improve them as it is already done in some other scientific disciplines.

Sharing research artifacts brings people together and raises interest.

The community continue being interested in our projects mainly because they are accompanied by all code and data enough to reproduce, validate and extend our model-driven optimization techniques. At the same time, sharing all research material in a unified way helped us to bring interdisciplinary communities together to explain performance anomalies, improve machine learning models or find missing features for automatic program and architecture optimization while treating it as a "big data" problem. We also used it to conduct internal student competitions to find the best performing predictive model. Finally, we used such data to automatically generate interactive graphs to simplify research in workgroups and to enable interactive publications (as shown in the following online example: c-mind.org/interactive-graph-demo).

Reproducibility should not be forced but can come as a side effect.

Furthermore, such community driven research helped us to expose a major problem that makes reproducibility in computer engineering very challenging. We have to deal with ever changing hardware and software stack making it extremely difficult to describe experiments with all software and hardware dependencies, and to explain unexpected behavior of computer systems. Therefore, just reporting and sharing experimental results including performance numbers, version of a compiler or operating systems and a platform is not enough -we need to preserve the whole experimental setup with all related artifacts and meta-information describing all software and hardware dependencies.

Collective mind: a new beginning.

This problem motivated us to start developing a new methodology and open source infrastructure (Collective Mind, c-mind.org) to gradually describe, categorize, preserve and share the whole experimental setups and all associated research artifacts with their meta-description as public and reusable components c-mind.org/repo, At the same time, we and the community benefit from public discussions and from agile development methodologies to continuously improve our techniques and tools.

After many years of evangelizing collaborative and reproducible research in computer engineering based on the presented practical experience, we finally start seeing the change in mentality in academia, industry and funding agencies. In our last ADAPT workshop (adapt-workshop.org authors of two papers (out of nine accepted) agreed to have their papers validated by volunteers. Note that rather than enforcing specific validation rules, we decided to ask authors to pack all their research artifacts as they wish (for example, using a shared virtual machine or as a standard archive) and describe their own validation procedure. Thanks to our volunteers, experiments from these papers have been validated, archives shared in our public repository (c-mind.org/repo), and papers marked with a "validated by the community" stamp.

TOWARDS A NEW PUBLICATION AND VALIDATION MODEL

Based on the above practical and mainly positive experiences, we propose a new publication model where preliminary evaluation of research artifacts and ideas is crowdsourced to an interdisciplinary community using available web services.

Open access archives.

Papers should be submitted to open access archives such as arXiv (arxiv.org) and HAL (hal.archives-ouvertes.fr). All related artifacts (code, data sets, models, experimental results) should be shared either at authors' web pages or at some public sharing web services such as (figshare.com). Finally, authors should submit links to their open access papers and related artifacts to a given workshop, conference or journal.

Public, threaded and ranked discussion forums.

After collecting all papers and related material, a new discussion topic for each paper should be created at some social networking service with a ranking system such as slashdot, stackexchange or reddit. Google+ or Facebook can be used too though just a number of "likes" or "dislikes" may be difficult to interpret. Authors will be strongly encouraged to engage into public discussions about their work.

Program committee filter.

Small program committee should read discussions to quickly get rid of publications where claims and experimental results are obviously wrong, unreproducible or possibly plagiarized. Note, that if authors disagree with the community (it may happen with too novel or controversial ideas), their public arguments should help pass this filter (similar to current rebuttal system). Remaining papers should be sent to a specially selected and possibly interdisciplinary committee based on topics of the submitted papers as well as reviews (to address specific concerns from the community).

Since we see a continuously growing number of papers submitted to workshops, conferences and journals, such approach can considerably reduce the burden of reviewers and help them focus on possible issues already identified by the community while improving relevance and quality of the reviews.

Final paper selection.

Program chairs can now select papers based on public discussions and professional reviews to ensure interesting and relevant discussions at a workshop or conference. We believe that public discussions can also help avoid anonymous and unfair paper rejections that are intended to keep monopoly on research. Finally, such approach can also help focus authors presentations on addressing questions and concerns raised during public discussions rather than having long and formal introductions of the techniques.

Online open access journals.

Our approach transparently enables open access journals -we can now immediately create online journal volumes from the most interesting and highest ranked publications. At the same time, existing and not necessarily open access journals can also invite extended publications.

Co-existence with traditional publication models.

Note that we do not advocate to completely substitute "closed" and professional reviewing at current conferences and journals. Neither do we advocate for an open access to all publications and research artifacts -it is normal if a company or a researcher would like to possibly patent and commercialize their work while still presenting it to the pub-lic. In such case, we still need to allow traditional submission to workshops, conferences or journals along with public submissions. However, we would still like to validate experimental results in these publications. In such cases, we may even envision that some committee members may need to sign NDA to validate such experimental results.

Therefore, our publication model can easily co-exist with current models instead of trying to abruptly substitute them. Furthermore, we hope that it will reduce reviewers' burden, improve quality and fairness of the reviews and will restore attractiveness of academic research in computer engineering as a traditional, collaborative and fair science rather than hacking, publication machine or monopolized business.

FUTURE WORK

We plan to validate the presented publication model at our next ADAPT workshop (adapt-workshop.org) and possibly at some existing conferences and journals in computer engineering.

Note, that experimental reproducibility comes naturally in our publication model as a side effect rather that only because it is a noble thing to do. However, we continue experiencing considerable difficulties when reproducing complex experimental setups from existing publications often due to specific requirements placed on operating systems, libraries, benchmarks, data sets, compilers, architecture simulators, and other tools, or due to a lack of precise specifications, lack of all software dependencies, and lack of access to some hardware.

Similar problems with reproducibility were also recently reported in several other related initiatives on validating experimental results [START_REF]Artifact evaluation for software conferences[END_REF]7,[START_REF]Occam (open curation for computer architecture modeling[END_REF]. Therefore, we decided to join together during the ACM SIGPLAN TRUST workshop [START_REF]located with PLDI'14[END_REF] to discuss technological aspects of enabling collaborative and reproducible research and experimentation particularly on program and architecture empirical analysis, optimization, simulation, co-design and run-time adaptation including how to:

• capture, catalog, systematize, modify, replay and exchange experiments (possibly whole setups with all artifacts including benchmarks, codelets, datasets, tools, models, etc);

• validate and verify experimental results;

• deal with a rising amount of experimental data using statistical analysis, data mining, predictive modeling, etc.

Finally, we will continue investigating frameworks and repositories to share the whole experimental setups with related artifacts and their meta-description including all software and hardware dependencies such as CARE (reproducible.io), CDE (www.pgbovine.net/cde.html), Docker (www.docker.io), IPython Notebook (ipython.org/notebook.html), Collective Mind (c-mind.org), and many others.

ACKNOWLEDGMENTS

We would like to thank all the participants of our events (BOFs, workshops, thematic sessions and panels) on collaborative and reproducible research and experimentation in computer engineering since 2008 including Jack Davidson, Lieven Eeckhout, Sascha Hunold, Anton Lokhmotov, Alex K. Jones, Bruce Childers, Daniel Mosse, Vittorio Zaccaria, Christian Bertin, Christophe Guillon, Christoph Reichenbach, Marisa Gil, Lasse Natvig, David Whalley, Cristina Silvano, Steve Furber, Paul Kelly, Thomas Wenisch, Davide del Vento, Jean Luc Gaudiot as well as cTuning and HiPEAC communities for interesting discussions and feedback.


X Jourdain

J.-B Colliat

C De Sa

F Benboudjema

F Gatuingt

Upscaling permeability for fractured concrete: meso-macro numerical approach coupled to strong discontinuities

A two scales numerical analysis is set up in order to upscale the permeability of fractured materials such as concrete. To that aim we couple FE kinematics enhancements (strong discontinuities) representing fine scale cracks to the fine scale permeability tensor. The latter may be split into two parts: the first one is isotropic and corresponds to flows within the porosity of the material; the second one, based upon a set of cracks with different orientations and openings, is anisotropic. For the latter each crack is a path for mass flow according to the Poiseuille law considering two infinite planes. We show how the upscaling procedure leads both to the definition of macroscopic permeability tensors as well as the flow rate evaluation for components of concrete structures.

Introduction

Mass (gas and water) transfers within concrete are an important issue dealing with numerous applications in Civil engineering such as geological CO 2 storage or civil nuclear industry. In France, the latter aims at extending its nuclear powerplants lifetime which requires accurate quantifications of the outflow through the concrete vessel along different cases and accounting for the long-term evolution of concrete properties and cracking. Under severe accident cases -e.g. LOCA: Loss-Of-Coolant Accident -, the stress and strain states may reach quite important values, leading to a set of macroscopic cracks. The main objective is then to assess that the leaking rate remains below some prescribed threshold, which is usually done thanks to some integrity tests.

On the physical point of view, macroscopic cracks lead to a macroscopic permeability that increases by several orders of magnitude and also exhibits a strong anisotropy due to cracks orientations [START_REF] Choinska | Effets de la température, du chargement mécanique et de leurs interactions sur la perméabilité du béton de structure[END_REF], [START_REF] Picandet | Crack effects on gas and water permeability of concretes[END_REF]. Except for low stress levels, linking the fractured state of concrete to the induced anisotropic permeability tensor is a difficult task [START_REF] Pijaudier-Cabot | Permeability due to the increase of damage in concrete : From diffuse to localized damage distributions[END_REF], [START_REF] Shao | Coupling between anisotropic damage and permeability variation in brittle rocks[END_REF]. The main reason for that is the broad use of macroscopic smeared crack models which are not providing accurate and physical quantities -such as cracks opening and orientation -in order to model fractures within a FE context. Actually, it is quite clear that the "discrete" nature of each macroscopic fracture -and thus of the corresponding flow -also requires a discrete numerical representation of cracks in order to set up the hydro-mechanical coupling on a physical basis. Such bridge have been made using, for example, lattice models [START_REF] Chatzigeorgiou | Coupling between progressive damage and permeability of concrete: analysis with a discrete model[END_REF]. On the other hand, considering a set of meso-scale cracks with different openings and orientations, the problem of determining the macroscopic permeability can also be handled in an analytical sense through self-consistent scheme [START_REF] Dormieux | Approche micromécanique du couplage perméabilité -endommagement[END_REF]. The latter shows that the order of magnitude of the permeability increases beyond a meso-scale crack density threshold. However, such analytical scheme requires to assume some constraint about the cracks distribution (e.g. isotropic orientations) and is thus mostly restricted to low levels or isotropic loading cases. Here we show that incorporating discontinuitieswhich are, by essence, discrete -within the FE interpolation of the displacements field also leads to a natural and accurate way to quantify both macroscopic flows and permeability tensors.

To that aim we consider a two scales approach, in the spirit of sequential multi-scale methods [START_REF] Feyel | Multi-scale non-linear FE 2 analysis of composite structures: damage and fiber size effects[END_REF]. The latter tend to build macroscopic models from a sequence of lower scale computations. Most of them rely on a probabilistic description of phases arrangement or material properties at the fine scale.

Here they require both a macroscale flow model -chosen among porous media flow theory -and a fine scale coupled hydromechanical analysis. By applying a set of specific boundary conditions at the mesoscale -fine scale -and assuming ergodicity, the spatial averages allow to compute macroscopic quantities, such as permeability tensors according to the chosen macroscopic flow model. This a posteriori upscaling makes sequential multi-scale methods quite popular in order to compute macroscopic properties, especially considering non-linear behavior for which analytical homogenization meets important theoretical challenges. It is worth noting that, whether ergodicity doesn't appear as a correct assumption (eg. dealing with non differentiable in time processes), the methodology is still valid, provided that the spatial averages are replaced by ensemble integrals. The latter may be advantageously computed through Monte-Carlo integration. The latter basically consists in considering several independent mesoscale realizations and in computing a posteriori statistics.

The outline of this paper is as follows: the sequential multi-scale framework is detailed in Section 2, as well as the cracks FE modeling and the hydro-mechanical coupling, both at mesoscale. In Section 3 we next turn to the mesoscale flow problem statement, considering both incompressible and compressible flows. Section 4 shows the results of the upscaling procedure, first dealing with different "idealized" cracks patterns. Finally we consider a Reinforced Concrete element submitted to tension and compare the numerical simulations to the main experimental results from [START_REF] Desmettre | Novel water permeability device for reinforced concrete under load[END_REF].

Sequential multi-scale framework

As opposed to integrated multi-scale methods, sequential ones require both a macroscopic model and a fine scale one. The former defines a set of macroscopic parameters which may be identified thanks to a sequence of fine scale computations along specific boundary conditions and spatial averaging. Here the macroscopic point of view is that mass transfers through concrete can be modeled in the sense of porous media flow [START_REF] Bear | Dynamics of Fluids in Porous Media[END_REF], which defines the macroscopic permeability as a symmetric and positive-definite second order tensor K M [m 2 ] according to,

Q M = - ρ µ K M • G M [kg.s -1 .m -2 ] (1)
where µ and ρ are the viscosity and the density of the fluid. Q M is the macroscopic mass flow density vector and G M is the macroscopic pressure gradient, both defined as spatial averages of the corresponding fine scale quantities:

Q M = 1 V V q(x) dV, G M = 1 V V grad(p) dV (2)
In order to compute each components of the tensor K M , a sequence of mesoscale computations have to be performed along specific boundary conditions which must be chosen according to the Hill-Mandel condition [START_REF] Hill | Elastic properties of reinforced solids: some theoretical principles[END_REF]. Such condition ensures that the dissipations at small and large scales are matching (in a statistical sense) and thus allows to evaluate the macroscopic constitutive response of heterogeneous media in terms of spatial averages. It has been reformulated in the case of porous media flow by [START_REF] Du | On the size of representative volume element for darcy law in random media[END_REF] leading us to stress on two kinds of uniform boundary conditions which are,

• the uniform pressure boundary condition (Dirichlet-type) defined as,

p(x) = G M • x + p 0 ∀x ∈ ∂Ω (3)
where G M is the pressure gradient which is, in this case, considered to be a constant vector.

To be more precise, considering G M = [1 0 0] T and the two other circular permutations lead to a straightforward way to compute the nine components of the macroscale permeability matrix K M .

• the uniform mass flow boundary condition (Neumann-type) as,

q(x) • n(x) = ρ(x)v(x) • n(x) = Q M • n(x) ∀x ∈ ∂Ω (4)
where Q M is a constant vector, n(x) is the unit normal vector and v is the filtration velocity. Considering Q M = [1 0 0] T and the two other circular permutations allows for a complete

definition of K M -1 .
The influence of the choice for the boundary conditions is discussed at the beginning of Section 4. However, whether the two results are diverging, we shall already stress on the ability of the uniform pressure case to provide more reliable results compared to analytical solutions.

Such two-scale framework thus requires to set up both a macro model (to be identified) and a mesoscale one. Here, following [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] the latter is based on a spatial truss representation in order to model the mechanical behavior of a two phases material (aggregates melt into mortar). The kinematics enhancements through a set of strain discontinuities lead to FE meshes which are not constrained by the physical interfaces, hence allowing for an accurate and simple way to handle complex mesoscale geometries [START_REF] Moës | A computational approach to handle complex microstructure geometries[END_REF]. On the other hand, the non-linear behaviour is captured by meso-scale cracks modeling through a set of displacement discontinuities.

Mesoscale failure FE modeling: embedded strong discontinuity

One of the key issues dealing with the numerical modeling of brittle and quasi-brittle materials is the fracture process modeling and its representation. From a physical point of view, fractures or cracks might be viewed as introducing displacement discontinuities within a continuum. For modeling aspects, cracking leads to the progressive decrease of the stiffness and eventually to softening behavior where strain increase is accompanied by the stress decrease. It is well-known that dealing with such kind of softening behavior leads to non-uniqueness of FE solutions with respect to the chosen mesh. Several numerical techniques have been developed during the past twenty years in order to regularize FE models including softening laws. Among them, it is worth citing the smeared crack model [START_REF] Hillerborg | Application of the fictious crack model to different types of materials[END_REF], the non-local approach [START_REF] Pijaudier-Cabot | Nonlocal damage theory[END_REF] and more recently the strong discontinuity approach - [START_REF] Wells | Application of embedded discontinuities for softening solids[END_REF], [START_REF] Brancherie | Novel isotropic continuum-discrete damage model capable of representing localized failure of massive structures. Part I: theoretical formulation and numerical implementation[END_REF], [START_REF] Moës | A finite element method for crack growth without remeshing[END_REF]. The latter has proven to be quite efficient without any requirement in terms of additional parameter and is widely used in order to model continuum material failure. Two alternatives, nodal (X-FEM [START_REF] Moës | A finite element method for crack growth without remeshing[END_REF]) and element (E-FEM [START_REF] Wells | Application of embedded discontinuities for softening solids[END_REF]) enrichments, are presently available for capturing displacement (strong) discontinuities. Deciding which one is the most suitable for the purpose of material failure simulation is still a controversial issue, out of scope of this work. The numerical simulations presented in this work have been carried out using element enrichments, which benefit from the static condensation procedure. The main advantage of such a methodology is to be able to provide numerical values for cracks opening and to preserve the total number of unknowns as well. Adding strong enhancements to the set of strain discontinuities thus lead to a non-linear modeling strategy which is oriented towards a more reliable interpretation of failure mechanisms for heterogeneous materials.

Here, within the context of the E-FEM methods, the mechanical analysis is based on [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] and [START_REF] Benkemoun | Anisotropic constitutive model of plasticity capable of accounting for details of meso-structure of two-phase composite material[END_REF], and relies on spatial truss models at meso-scale. Such truss is generated by first computing the 3D Delaunay triangulation of a Poisson point process over the spatial domain of interest in accordance with a prescribed points density. Each edge of the resulting tetrahedral elements is then converted into a bar element whose cross-section is computed by mean of the corresponding Voronoi tessellation. Finally, spherical inclusions are generated from the Gibbs point process, taking into account both prescribed volume fraction and inclusion diameters.

Moreover, dealing with brittle and quasi-brittle materials, pretty simple failure mechanisms are introduced at meso-scale. The chosen yield function Φ, which leads to activating the strong discontinuities within the elements, corresponds to tensile fracture and mode I opening. Here it is written as,

Φ(t, q) = t -(σ f -q) ≤ 0 ( 5
)
where t is the traction vector at the discontinuity and σ f the limit stress. The softening is introduced through the variable

q = f ([[u]]) by considering the exponential form, f ([[u]]) = σ f 1 -exp - σ f G f [[u]] (6)
where [[u]] = u +u -is the displacement jump -which is assumed to be the image of the crack opening and belongs to the set of unknowns -and the fracture energy Gf [J.m -2 ] is introduced as the area under the t vs. [[u]] curve (see Fig. 1). It is worth noting that such fine scale failure criterion is triggered only for fracture in tension (or equivalently in case of extension dealing with truss elements) at meso-scale, which is typical of brittle or quasi-brittle materials like cement-based ones. However, [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] showed that the macroscopic mechanical response of such models exhibits failure modes along several macroscopic proportional loading paths, such as simple tension and compression, shear, bi-axial tension and compression, etc. Moreover, here the key point are the embedded displacement discontinuities which are assumed to model meso-scale cracks through a finite jump within the displacement interpolation. The magnitude [[u]] of this jump is nothing else but the crack opening. It is quite clear that such an information leads to a straightforward way to compute mass flows within meso-scale cracks. Moreover the set of cracks orientations clearly gather the whole information dealing with the fracture pattern anisotropy and thus allows to set up an accurate hydro-mechanical coupling at such fine scale by the mean of Finite Element assembly procedure. This point is detailed in the next section.

Meso-scale coupling through the Poiseuille law

The meso-scale mechanical representation developed in [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] is based on a spatial truss built thanks to a Poisson point process [START_REF] Cox | Point Processes[END_REF] and its Delaunay triangulation. The latter defines a set of two nodes finite elements, which kinematics are enhanced in order to represent both heterogeneities and fine scale cracks. Here we assume that each of those crack is a path for a mass flow, according to the Poiseuille law written in case of two infinite parallel planes. Obviously, the distance between those planes is equal to the meso-crack opening or displacement jump w

= [[u]] = u + -u -.
Dealing with an incompressible fluid, any meso-scale crack -which unit normal vector is nleads to an equivalent fine scale porous media, with permeability tensor as,

K m = k intr 1 + w 3 12L 1 -n ⊗ n ( 7
)
where L is the length of a typical element including a strong discontinuity of magnitude w and k intr is the intrinsic permeability of the material depending upon the porosity and the saturation degree (e.g. 10 -17 m 2 for ordinary concrete). It is worth noting that k intr must be strictly positive in order to get a full rank matrix K m .The corresponding mass flow density vector q, due to such meso-scale crack, can thus be written as:

q = -ρ K m µ • grad(p) (8)
This mass flow vector is clearly oriented along the crack and the latter has no influence in the normal direction:

q • n = -ρ k intr µ grad(p) • n (9)
Considering a compressible fluid, here assumed to follow the ideal gas law,

ρ = p M RT ( 10
)
where M is its molar mass (kg.mol -1 ), R is the universal gas constant (8, 314 J.K -1 .mol -1 ) and T the absolute temperature (K), the density cannot be assumed to remain constant and (8) must be reformulated as,

q = - K m µ M RT p • grad(p) (11)
or, in a more practical way as:

q = - K m 2µ M RT • grad(p 2 ) (12)
Equation ( 12) is very similar to [START_REF] Desmettre | Novel water permeability device for reinforced concrete under load[END_REF], apart from showing a linear relationship between the mass flow density and the gradient of the pressure-squared field and not the pressure field itself. This remark suggests a common resolution scheme for both compressible and incompressible flows (see next section).

Having this fine scale hydro-mechanical coupling in hands, it is clear that any mass flow problem shall inherit from most of the information coming from the mechanical meso-scale analysis. The corresponding set of meso-scale cracks, each showing different openings and orientations, shall lead to a straightforward way to account for both induced anisotropy, fracture tortuosity and percolation issue. In order to set up such information upscaling, we here rely on a FE formulation of the flow problem at meso-scale. Hence, by defining an elementary permeability matrix for each element and by applying the FE assembly procedure, the resolution of this problem leads to a complete definition of the flow solution. The next section focuses on the FE formulation of this flow problem.

FE formulation of the global flow problem

The keystone of any sequential multi-scale analysis is obviously the ability to numerically solve physical problems at the chosen "fine" scale. Here, we focus on porous media flow problems within the context of the hydro-mechanical coupling presented above. As stated previously, the latter leads to a heterogeneous field of anisotropic permeability tensors. Moreover we aim at gathering within a common numerical scheme both compressible and incompressible flows. Since the latter is extensively described in numerous textbooks [START_REF] Bear | Dynamics of Fluids in Porous Media[END_REF], [START_REF] Brezzi | Mixed and hybrid finite element methods[END_REF], here we focus on compressible fluids, for which using the pressure-squared field leads to such a common FE simulation scheme. We start by recalling the weak form of the mass balance equation, before turning to the FE spatial discretization. Finally we provide some details dealing with the elementary matrix computation.

Weak form of the mass balance equation

Assuming steady-state flows and no source, the local -strong -form of the mass balance equation is,

div(ρv) = div(q) = 0 ( 13
)
where q is still the mass flow density vector [kg.s -1 .m -2 ]. Such form -substituting mass flow to filtration velocity -is suitable for both incompressible and compressible cases. The corresponding weak form can be written as follows:

Find p 2 ∈ S(Ω), such that ∀p ⋆2 ∈ V (Ω): Ω p ⋆2 div(q(p 2 )) dΩ = 0 (14)
Here S(Ω) is the admissible pressure-squared field space (an affine space),

S(Ω) = {p 2 ∈ H 1 (Ω)|p 2 (∂Ω) = p 2 0 } (15)
where

H 1 (Ω) = {p 2 ∈ L 2 (Ω); ∀i = 1...n, ∂p 2 ∂x i ∈ L 2 (Ω)} is a Hilbert space. V (Ω)
is the admissible pressure-squared fields space to zero (i.e. nil on the part of the boundary for which Dirichlet conditions are applied):

V (Ω) = {p ⋆2 ∈ H 1 (Ω)|p ⋆2 (∂Ω) = 0} (16)
With both an integration by parts and the Green-Ostrogradski theorem, equation ( 14) becomes,

δΩq p ⋆2 q 0 • n ds - Ω grad(p ⋆2 ) • q dΩ = 0 (17)
which is the basis to compute an approximate solution p 2,h of the flow problem.

Approximate FE solution

A solution to ( 17) is seeked within a finite dimensional subspace S h (Ω h ) ⊂ S(Ω). Providing a finite element mesh Ω h = n el e=1 Ω e of the domain, an ansatz function N a (x) is associated to each node of this mesh. The whole set of these ansatz functions span the finite-dimensional space S h (Ω h ) of which they form a basis. Over a finite element Ω e , the approximate solution p 2,h can thus be written as,

p 2,h (x) Ωe = a N a (x)p 2 a = N.p 2 e ( 18
)
where the vector p 2 e contains the pressure-squared values on each node of Ω e . Gathering the derivatives of the ansatz functions within elementary matrices B e , we may write the gradient of the pressuresquared field as,

grad h (p 2 ) Ωe = B e • p 2 e ( 19
)
With the above definitions and the approximate weak form on Ω h coming from ( 17), we obtain a set of equations,

r h := r(p 2,h ) = f int (p 2,h ) -f ext = 0 (20)
where

f int = - n el A e=1 Ωe B T e • q dΩ (21)
is the internal forces vector and A n el e=1 is the finite element assembly operator. Still dealing with compressible flows, [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] provides a linear relationship between the mass flow density vector q and the pressure-squared field p 2 . Including this relation in [START_REF] Cox | Point Processes[END_REF] leads to a set of linear equations to be solved,

K • p 2,h = f ext ( 22
)
where K is the FE permeability matrix associated to the chosen mesh Ω h ,

K = n el A e=1 K e (23)
and K e are the elementary permeability matrix:

K e = Ωe B T e • M RT K m 2µ • B e dΩ (24)

Elementary permeability matrix

Considering [START_REF] Feyel | Multi-scale non-linear FE 2 analysis of composite structures: damage and fiber size effects[END_REF], the elementary permeability matrix defined by (24) can obviously be split into two parts, K e = K e iso + K e aniso (25)

where K e iso is the isotropic part corresponding to the uncracked material,

K e iso = Ωe B T e M RT k intr 2µ • B e dΩ (26)
and K e aniso is the anisotropic part linked to mesoscale failures: Here we deal with 4-nodes tetrahedron element which thus consist of six edges. Hence, each of those edges represents an element within the mechanical fine scale lattice (see Fig. 2 where one flow analysis element is represented -a 4-nodes tetrahedron -with one strong discontinuity) and thus may be associated to a fine scale crack whose opening is computed numerically. Consequently, the anisotropic part of (25) has to be written as,

K e aniso = Ωe B T e • M µRT w 3 24L 1 -n ⊗ n • B e dΩ (27) Y X Z w i n i
K e aniso = 6 i=1 Ωe B T e • M µRT w 3 i 24L 1 -n i ⊗ n i • B e dΩ ( 28
)
where the set of cracks associated to element Ω e has n i orientations and w i openings.

It is worth noting that, on the numerical procedure point of view, K e iso evaluation requires a single numerical integration point. On the other hand, considering the set of six edges of Ω e , K e aniso evaluation can thus be viewed according to six numerical integration points.

Assembling the elementary permeability matrix (25) and solving the set of linear equations ( 22) leads to the approximate solution of the flow problem. This solution consists of the pressure field for incompressible fluid and of the pressure-squared field dealing with compressible ones. Both can thus be solved using the same FE code and procedures, and the only slight difference then remains in considering the pressure-squared for compressible flows.

With this two-scales numerical tool in hands we now turn to some specific numerical examples in order to demonstrate its main feature.

Numerical examples and upscaling validation

On the physical point of view, the macroscopic permeability tensor must clearly inherits from the anisotropy due to the crack patterns. The numerical examples presented in this section show that the upscaling process leads to such result thanks to the Finite Element assembly procedure. To that aim, we first consider "perfect" failure patterns -which consist of a single plane crack with constant opening from 10 -6 mm to 10 -2 mm -inside a cubic domain. We compute the macroscopic permeability tensor along different orientations and opening values. Then we focus on reinforced concrete (RC) element submitted to simple tension and for which a novel permeability device has been developped by [START_REF] Desmettre | Novel water permeability device for reinforced concrete under load[END_REF].

On the Software Engineering point of view, those computations are based upon the FE simulator component coFeap [START_REF] Kassiotis | coFeap's Manual[END_REF] which allows for multiple instantiations and asynchronous communication. Hence the sequence of fine scale computations, which is the keystone of any sequential multi-scale method, may be performed in parallel using the same data set. Each of those computations consists in solving a compressible or incompressible flow problem using a fine mesh (here 338 436 nodes and 1 933 643 tetrahedrons). Although mesh convergence studies (see Fig. 3) show that an asymptotic response is obtained for much coarser grids, the chosen mesh for the flow problem must match with the spatial truss one. The latter's size is related to the diameter of the smallest inclusions to be modeled (here 1 mm).

In order to solve the linear system (22) -or its counterpart dealing with incompressible flowswe choose for wellknown iterative solver, like preconditioned conjugate gradient [START_REF] Schewchuk | An introduction to the conjugate gradient method without the agonizing pain[END_REF]. mm. Apart from this specific path for mass flow, the whole domain (100 3 mm 3 ) is assumed to be homogeneous and with isotropic permeability k intr = 10 -17 m 2 . It is worth noting that such strictly positive value is mandatory in order to deal with full-rank permeability tensor [START_REF] Feyel | Multi-scale non-linear FE 2 analysis of composite structures: damage and fiber size effects[END_REF].

"Perfect" failure patterns

Following the sequential multi-scale framework, a set of three different uniform pressure boundary conditions are imposed to the domain, leading to a complete determination of the macroscopic permeability tensor K M . The three matrices (29), (30) and (31) show the evolution of this computed influence on the mass transfer properties. The macroscopic permeability tensor is then equal to the homogeneous meso-scale one. On the contrary, when dealing with larger openings, the influence of the crack becomes predominant. First, (31) shows a strong anisotropy which is clearly induced by the crack pattern (here a perfect plane). Second, the non diagonal components are no more equal to zero, especially considering the values that represents the cross-permeability within the plane defined by the crack. It is also worth noting that, although the above matrices are not strictly symmetric -which is mainly due to numerical precision dealing with iterative solvers -the norm of the nonsymmetric part of (31) is neglectable comparing to its symmetric part norm (less than 0.1 %).

Moreover, we stress here on the influence of the boundary conditions by comparing the two main cases offered by the Hill condition: "uniform pressure" or Dirichlet-type boundary conditions (3) and "uniform mass flow" or Neumann-type boundary conditions (4). Figure 5 shows that this influence increases as the crack opening is growing as well. This is mainly due to the fact that, considering a single and oriented crack, the domain can be viewed as a Representative Volume Element provided the opening is very small only. When considering larger openings, the cube is not a RVE anymore, which leads to a major influence of the boundary conditions. In that case, Figure 6 shows that the uniform pressure choice is much more closer to the expected result -here the Poiseuille law -than the uniform mass flow one. Hence we choosed for the former in the subsequent results. This result is in accordance with the postulat formulated by Hill for mechanical problems [START_REF] Hill | Elastic properties of reinforced solids: some theoretical principles[END_REF]. He explains that the Representative Volume Element exists when the ratio of the mesoscopic length (length of the sample) over the microscale length (average size of the heterogeneity) "(a) is structurally entirely typical of the whole mixture on average, and (b) contains a sufficient number of inclusions of the apparent overall moduli to be effectively independent of the surface values of traction and displacement so long as these values are macroscopically uniform". In our study, as soon as the crack opens, the sample can't be seen as a RVE as it is "cut" in two parts which is in contradiction with the (a) proposition of Hill. The (b) proposition is also wrong as there is only one crack, which means one heterogeneity in the sample and therefore not a sufficient number of inclusions. It is also worth noting that the influence of the crack on the mesoscale mass flow and thus on the macroscopic permeability tensor begins with quite small opening (around 1µm).

Permeability of RC element under load

The multiscale framework we present here is suitable for mass transfers within concrete structures or their components. To that aim we focus on experimental results from [START_REF] Desmettre | Novel water permeability device for reinforced concrete under load[END_REF] who designed a coupled tensile -permeability test on Reinforced Concrete (RC) specimens (610 × 90 × 90 mm 3 concrete element including a 11 mm diameter reinforcement bar). Here we aim at comparing their experimental measures to numerical results and focus on the permeability evaluation along the failure process.

The fine scale mechanical analysis of this RC tie is based on a spatial truss representation [START_REF] Benkemoun | Failure of heterogeneous materials: 3d meso-scale fe models with embedded discontinuities[END_REF] built with non-adapted meshes. In order to fit to the experimental conditions, displacements are prescribed at both ends of the steel reinforcement bar. Such increasing load leads to progressive cracking of the concrete element and Figure [START_REF] Bear | Dynamics of Fluids in Porous Media[END_REF] shows a typical crack pattern obtained from a numerical analysis. Three main macroscale cracks are distributed along the tie which is in accordance with experimental observations. Moreover, we show on Figure ( 9) that there is a quite good agreement between the measured values of those cracks openings during the loading process and the corresponding numerical values. On the permeability assessment point of view (here the test deals with water), Figure [START_REF] Hill | Elastic properties of reinforced solids: some theoretical principles[END_REF] shows the norm of the mass flow vector at the end of the failure process. In order to match the experiments, this computation has been made imposing mixed boundary conditions: Dirichlet-type along two opposite faces of the specimen and Neumann-type (with zero flow rate) for the four other faces. Although the concrete specimen contains a large number of mesoscale cracks, it is clear that the mass transfer takes place within a subset of those cracks, corresponding to several percolated paths. Thus, on the mass transfer point of view, the former may be seen as a set of macroscale cracks. Hence, it is worth noting that, apart from considering the opening value as the pertinent criterion, this mass transfer analysis leads to an other way to determine this set of macroscale cracks. This analysis being linear and so quite simple to drive, it is a very convenient way to characterize macroscale cracks.

Finally, Figure [START_REF] Du | On the size of representative volume element for darcy law in random media[END_REF] shows the permeability coefficient -here in [m.s -1 ] in order to match with the experimental results -evolution along the load increase. The permeability increases from approximatively 2.10 -10 m.s -1 to 1.10 -5 m.s -1 both for numerical and experimental studies. It is also worth noting that the increasing rate is also quite well represented. Yet, the permeability rise appears for smaller loading values in the numerical study than in the experimental one. Considering the concrete

Conclusions and outlooks

In this work we have discussed the use of a sequential two-scales (meso-macro) numerical strategy in order to upscale the permeability of fractured media such as concrete. Sequential multi-scales methods aim at building macroscopic models from a sequence of lower scale computations and require both a macroscale model -here porous media flow -and a fine scale numerical analysis. Such simple upscaling processes made sequential multi-scale methods quite popular in order to compute macroscopic properties of heterogeneous media.

Here the cornerstone relies in the coupling of strong discontinuities -which are supposed to model fine scale fractures within the FE mechanical model -to the fine scale permeability tensor through Poiseuille law. Such coupling is made possible thanks to the strong discontinuity approach which provides the opening value for each of these cracks. Indeed, at such meso level -which we assume to represent heterogeneities from 1 mm -each crack is a path for an oriented flow and, except for low stress levels, the upscaling process is not possible to manage on a analytical basis. We have presented different numerical tests showing the ability of the numerical upscaling process to model anisotropic macroscopic permeability tensor which confirm the intuitive idea that the whole set of fine cracks cannot lead to an isotropic permeability tensor.

Furthermore, we have compared some experimental results obtained on Reinforced Concrete elements by [START_REF] Desmettre | Novel water permeability device for reinforced concrete under load[END_REF]. Here the heterogeneities are the reinforcement bars and we compute both the mass flow vector and the resultant macroscopic permeability. When compared to the experiments the two-scales numerical analysis shows a good agreement. However, we can observe a high discrepancy within the experimental data. Consequently, further tests dealing with components of RC structures are needed before a complete assessment may be reached.

Finally, it is worth noting that any upscaling process of the permeability may be viewed as an advantageous tool in order to define whether the fracture pattern is percolated (or connected) or not. Actually such feature comes as a by-product results of the two-scales analysis. Hence, to the authors point of view, important efforts should be paid in the near future in order to develop those multi-scale strategies, rather within an integrated framework.

Figure 1 :

 1 Figure 1: Strong discontinuity crack representation and crack opening process

Figure 2 : 4 -

 24 Figure 2: 4-nodes tetrahedron flow element with one mesoscale crack Equation (27) states for one mesoscale crack -oriented along n -only. Here we deal with 4-nodes tetrahedron element which thus consist of six edges. Hence, each of those edges represents an element within the mechanical fine scale lattice (see Fig.2where one flow analysis element is represented -a 4-nodes tetrahedron -with one strong discontinuity) and thus may be associated to a fine scale crack whose opening is computed numerically. Consequently, the anisotropic part of (25) has to be written as,

Figure 4

 4 Figure4shows a single plane crack with constant opening range from [[u]] = 10 -6 mm to [[u]] = 10 -2 mm. Apart from this specific path for mass flow, the whole domain (100 3 mm 3 ) is assumed to be homogeneous and with isotropic permeability k intr = 10 -17 m 2 . It is worth noting that such strictly positive value is mandatory in order to deal with full-rank permeability tensor[START_REF] Feyel | Multi-scale non-linear FE 2 analysis of composite structures: damage and fiber size effects[END_REF].Following the sequential multi-scale framework, a set of three different uniform pressure boundary conditions are imposed to the domain, leading to a complete determination of the macroscopic permeability tensor K M . The three matrices (29), (30) and (31) show the evolution of this computed

Figure 5 :

 5 Figure 5: Influence of the boundary conditions : Comparison of Dirichlet and Neumann-type conditions

Figure 6 :Figure 7 :

 67 Figure 6: Influence of the boundary conditions : Comparison to analytical solution

Figure 8 :

 8 Figure 8: Evolution of the principal components of the macroscopic permeability tensor along the crack opening: '•' stand for the normal direction and '×' for the tangent directions

Figure 9 :

 9 Figure 9: RC tie numerical analysis: a) Numerical crack patterns, b) Maximum crack opening versus load (experimental [8] vs computational results)

Figure 10 :

 10 Figure 10: RC tie numerical analysis: Numerical values of the mass flow vector norm

Figure 11 :

 11 Figure 11: RC tie numerical analysis: Water permeability coefficient versus load [8] vs numerical results

1.000 0.000 0.000 0.000 1.000 0.000 0.000 0.000 1.000

1.022 0.000 0.000 0.000 1.170 0.000 0.000 0.000 1.054

Clearly, (29) shows that a very tiny crack opening (comparing to the whole domain size) has no