5,003 research outputs found
Study of the compressive response of masonry using non-conventional joint materials
Winner of the International Journal of Masonry Research and Innovation IJMRI Best Paper Award 2017The compressive response of masonry is influenced by geometric, material and execution variables. In addition, the nature of bricks and mortar typically introduces uncertainty to the experimental results. In order to reduce this uncertainty, an experimental campaign has been carried out to analyse the influence of the properties of the joints. Four non-conventional masonry typologies including resin, EPS and rubber joints have been considered for this purpose. In all, 60 compressive tests and 50 deformability tests on five stacked bricks prisms were performed. Obtained data are compared with data from the literature. A comparison with the current European standard is also carried out. The obtained results point out that the modulus of linear deformation of the joint is the most influent variable on the compressive response of masonry. Finally, it seems that current formulation (Eurocode-6) tends to overestimate the modulus of linear deformation of masonry.Peer ReviewedAward-winningPostprint (author's final draft
Utilisation de processus légers pour l'exécution de programmes à parallélisme de données : étude expérimentale
Ce rapport présente une étude de quelques aspects importants des processus légers pour leur utilisation à l'exécution de programmes à parallélisme de données. La surcharge de l'environnement d'exécution, le coût des synchronisations globales, de création de processus légers, le comportement des processus légers vis-à-vis des communications ainsi que le coût de la migration des processus légers sont étudiés. Nous en déduisons des critères simples pour la détermination de la «bonne» taille des processus légers en relation avec le surcoût engendré. L'environnement d'exécution choisi est \PM2 car %d'une part ses sources sont disponibles et d'autre part il intègre la migration de processus légers
A Calculus Enabling Reuse and Composition of Component Assembly Specialization Processes
Software specialization exists in various forms in the literature ranging from product lines to adaptation of high-performance applications. In particular, specialization of component assemblies has been the focus of extensive research throughout the years and brings about specific challenges such as variant selection and hierarchy. We argue that many (possibly automatic) assembly specialization processes share a common structure. This paper presents a calculus which aims at providing a generic framework to ease reuse and composition of component assembly specialization processes. We show how this calculus can encode various features from the component model literature and discuss the existence of specialization processes in the literature and the usefulness of reusing and composing them
Scheduling Rigid, Evolving Applications on Homogeneous Resources
Classical applications executed on clusters or grids are either rigid/moldable or workflow-based. However, the increase of resource computing and storage capabilities has leveraged more complex applications. For example, some code coupling applications exhibit changing resource requirements without being a workflow. Executing them on current batch schedulers leads to an inefficient resource usage, as a block of resources has to be reserved for the whole duration of the application. This paper studies the problem of offline scheduling of rigid and evolving applications on homogeneous resources. It proposes several scheduling algorithms and evaluates them based on simulations. Results show that significant makespan and resource usage improvement can be achieved with short scheduling computing time
High Performance Composition Operators in Component Models
International audienceScientific numerical applications are always expecting more computing and storage capabilities to compute at finer grain and/or to integrate more phenomena in their computations. Even though, they are getting more complex to develop. However, the continual growth of computing and storage capabilities is achieved with an increase complexity of infrastructures. Thus, there is an important challenge to define programming abstractions able to deal with software and hardware complexity. An interesting approach is represented by software component models. This chapter first analyzes how high performance interactions are only partially supported by specialized component models. Then, it introduces HLCM, a component model that aims at efficiently supporting all kinds of static compositions
Enabling Connectors in Hierarchical Component Models
The continual growth of computing and storage capabilities enables scientific numerical applications to integrate more and more phenomena in their computations at the price of increased complexity. Hierarchical component models appear as an interesting approach to handle such complexity. However defining and implementing efficient interactions between hierarchical components is a difficult task, especially in the case of parallel and distributed applications. Connectors originating from Architecture Description Languages (ADL) offer a promising solution to this problem. There are however some cases where a simple combination of hierarchy and connectors in a single component model forces users to choose between an efficient implementation of components and their black box behavior. This paper describes HLCM, a model with connectors and hierarchy that provides /open connections/ as a mechanism to describe component interface that enhances encapsulation and eases component implementation replacement while supporting efficient interactions. Complex interactions such as data sharing and parallel method calls are successfully supported by HLCM. An implementation, based on model transformation and on CCM, illustrates its feasibility and benefits.La croissance continue des capacités de calcul et de stockage permet aux applications numériques d'intégrer un nombre croissant de phénomènes dans leurs calculs au prix d'une complexité accrue. Les modèles de composants hiérarchiques apparaissent comme une approche intéressante pour gérer cette complexité. Cependant, définir et implémenter des interactions efficaces entre composants hiérarchiques est une tâche difficile, d'autant plus dans le cas d'applications parallèles et distribuées. Les connecteurs issus des langages de description d'architecture (ADL) offrent une solution prometteuse à ce problème. Il y a cependant des cas où une simple combinaison de la hiérarchie et des connecteurs dans un modèle de composants unique oblige l'utilisateur à faire un choix entre des mises en œuvres efficaces pour les composants et leur comportement «boîte noire». Ce papier décrit HLCM, un modèle avec connecteurs et hiérarchie qui fournit le concept de /connexions ouvertes/ pour decrire les interfaces de composants. Ce méchanisme améliore l'encapsulation et facilite le remplacement des mises en œuvre de composant tout en permettant des interactions efficaces. Des interactions complexes telles que le partage de données ou les invocations de méthodes parallèles sont gérées avec succès par HLCM. Une mise en œuvre basée sur une transformation de modèle et sur CCM est utilisée pour illustrer sa faisabilité et ses bénéfices
Towards Scheduling Evolving Applications
International audienceMost high-performance computing resource managers only allow applications to request a static allocation of resources. However, evolving applications have resource requirements which change (evolve) during their execution. Currently, such applications are forced to make an allocation based on their peak resource requirements, which leads to an inefficient resource usage. This paper studies whether it makes sense for resource managers to support evolving applications. It focuses on scheduling fully-predictably evolving applications on homogeneous resources, for which it proposes several algorithms and evaluates them based on simulations. Results show that resource usage and application response time can be significantly improved with short scheduling times
An RMS Architecture for Efficiently Supporting Complex-Moldable Applications
International audienceHigh-performance scientific applications are becoming increasingly complex, in particular because of the coupling of parallel codes. This results in applications having a complex structure, characterized by multiple deploy-time parameters, such as the number of processes of each code. In order to optimize the performance of these applications, the parameters have to be carefully chosen, a process which is highly resource dependent. However, the abstractions provided by current Resource Management Systems (RMS) - either submitting rigid jobs or enumerating a list of moldable configurations - are insufficient to efficiently select resources for such applications. This paper introduces CooRM, an RMS architecture that delegates resource selection to applications while still keeping control over the resources. The proposed architecture is evaluated using a simulator which is then validated with a proof-of-concept implementation on Grid'5000. Results show that such a system is feasible and performs well with respect to scalability and fairness
A Generic Model Driven Methodology for Extending Component Models
Software components have interesting properties for the development of scientific applications such as easing code reuse and code coupling. In classical component models, component assemblies are however still tightly coupled with the execution resources they are targeted to. Dedicated concepts to abstract assemblies from resources and to enable high performance component implementations have thus been proposed. These concepts have not achieved widespread use, mainly because of the lack of suitable approach to extend component models. Existing approaches -- based on ad-hoc modifications of component run-times or compilation chains -- are complex, difficult to port from one implementation to another and prevent mixing of distinct extensions in a single model. An interesting trend to separate application logic from the underlying execution resources exists; it is based on meta-modeling and on the manipulation of the resulting models. This report studies how a model driven approach could be applied to implement abstract concepts in component models. The proposed approach is based on a two step transformation from an abstract model to a concrete one. In the first step, all abstract concepts of the source model are rewritten using the limited set of abstract concepts of an intermediate model. In the second step, resources are taken into account to transform these intermediate concepts into concrete ones. A prototype implementation is described to evaluate the feasibility of this approach
Untying RMS from Application Scheduling
As both resources and applications are becoming more complex, resource management also becomes a more challenging task. For example, scheduling code-coupling applications on federations of clusters such as Grids results in complex resource selection algorithms. The abstractions provided by current Resource Management Systems (RMS) - usually rigid jobs or advance reservations - are insufficient to enable such applications to efficiently select resources. This paper studies an RMS architecture that delegates resource selection to applications while the RMS still keeps control over the resources. The proposed architecture is evaluated using a simulator which is then validated with a proof-of-concept implementation. Results show that such a system is feasible and performs well with respect to fairness and scalability.Comme les ressources ainsi que les applications deviennent de plus en plus complexes, la gestion des ressources devient également plus complexe. Par exemple, l'ordonnancement d'application à base de couplage de code sur une fédération des grappes, comme par exemples les grilles, demande des algorithmes complexes pour la sélection de ressources. Les abstractions offertes par les gestionnaires de ressources (RMS - Resource Management Systems) - les tâches rigide ou les réservations en avance - sont insuffisantes pour que de telles applications puissent sélectionner les ressources d'une manière efficace. Cet article s'intéresse à une architecture RMS qui délègue la sélection des ressources aux lanceurs d'applications mais qui continue de garder le contrôle des ressources. L'architecture proposée est évaluée avec des simulations, qui sont validées avec un prototype. Les résultats montrent qu'un tel système est faisable et qu'il se comporte bien vis à vis de l'extensibilité et de l'équité
- …