Construction of higher‐order curl‐conforming finite elements and its assembly

Different choices are available when constructing vector finite element bases in real coordinates. In this communication, two different designs of higher‐order curl‐conforming basis functions are introduced and explained, showing the particularities of its assembly. Tetrahedra and hexahedra are used as element shapes to assess the effect of triangular and quadrilateral faces on the two considered constructions of basis functions. A comparison of their robustness in terms of the condition number of the finite element matrices for a number of distortions is included.     

An Appearance Model for Textile Fibers

Accurately modeling how light interacts with cloth is challenging, due to the volumetric nature of cloth appearance and its multiscale structure, where microstructures play a major role in the overall appearance at higher scales. Recently, significant effort has been put on developing better microscopic models for cloth structure, which have allowed rendering fabrics with unprecedented fidelity. However, these highly‐detailed representations still make severe simplifications on the scattering by individual fibers forming the cloth, ignoring the impact of fibers' shape, and avoiding to establish connections between the fibers' appearance and their optical and fabrication parameters. In this work we put our focus in the scattering of individual cloth fibers; we introduce a physically‐based scattering model for fibers based on their low‐level optical and geometric properties, relying on the extensive textile literature for accurate data. We demonstrate that scattering from cloth fibers exhibits much more complexity than current fiber models, showing important differences between cloth type, even in averaged conditions due to longer views. Our model can be plugged in any framework for cloth rendering, matches scattering measurements from real yarns, and is based on actual parameters used in the textile industry, allowing predictive bottom‐up definition of cloth appearance.     

A comparative evaluation of hybrid distributed shared-memory systems

Distributed Shared-Memory (DSM) systems are shared-memory multiprocessor architectures in which each processor node contains a partition of the shared memory. In hybrid DSM systems coherence among caches is maintained by a software-implemented coherence protocol relying on some hardware support. Hardware support is provided to satisfy every node hit (the common case) and software is invoked only for accesses to remote nodes.In this paper we compare the design and performance of four hybrid distributed shared memory (DSM) organizations by detailed simulation of the same hardware platform. We have implemented the software protocol handlers for the four architectures. The handlers are written in C and assembly code. Coherence transactions are executed in trap and interrupt handlers. Together with the application, the handlers are executed in full detail in execution-driven simulations of six complete benchmarks with coarse-grain and fine-grain sharing. We relate our experience implementing and simulating the software protocols for the four architectures.Because the overhead of remote accesses is very high in hybrid systems, the system of choice is different than for purely hardware systems.     

Exploiting selective instruction reuse and value prediction in a superscalar architecture

In our previously published research we discovered some very difficult to predict branches, called unbiased branches. Since the overall performance of modern processors is seriously affected by misprediction recovery, especially these difficult branches represent a source of important performance penalties. Our statistics show that about 28% of branches are dependent on critical Load instructions. Moreover, 5.61% of branches are unbiased and depend on critical Loads, too. In the same way, about 21% of branches depend on MUL/DIV instructions whereas 3.76% are unbiased and depend on MUL/DIV instructions. These dependences involve high-penalty mispredictions becoming serious performance obstacles and causing significant performance degradation in executing instructions from wrong paths. Therefore, the negative impact of (unbiased) branches over global performance should be seriously attenuated by anticipating the results of long-latency instructions, including critical Loads. On the other hand, hiding instructions’ long latencies in a pipelined superscalar processor represents an important challenge itself. We developed a superscalar architecture that selectively anticipates the values produced by high-latency instructions. In this work we are focusing on multiply, division and loads with miss in L1 data cache, implementing a dynamic instruction reuse scheme for the MUL/DIV instructions and a simple last value predictor for the critical Load instructions. Our improved superscalar architecture achieves an average IPC speedup of 3.5% on the integer SPEC 2000 benchmarks, of 23.6% on the floating-point benchmarks, and an improvement in energy-delay product (EDP) of 6.2% and 34.5%, respectively. We also quantified the impact of our developed selective instruction reuse and value prediction techniques in a simultaneous multithreaded architecture (SMT) that implies per thread reuse buffers and load value prediction tables. Our simulation results showed that the best improvements on the SPEC integer applications have been obtained with 2 threads: an IPC speedup of 5.95% and an EDP gain of 10.44%. Although, on the SPEC floating-point programs, we obtained the highest improvements with the enhanced superscalar architecture, the SMT with 3 threads also provides an important IPC speedup of 16.51% and an EDP gain of 25.94%.     

Pervaho: A specialized middleware for mobile context-aware applications

The concept of context-awareness offers a great potential for the future of mobile applications. In order to be developed in an optimal way, mobile context-aware applications need appropriate middleware services. This paper introduces Pervaho, an integrated middleware aimed specifically at supporting the development and testing of mobile context-aware applications. To illustrate the use of Pervaho, we walk through the development of a concrete mobile application and show how it can be built on top of Pervaho’s location-based publish/subscribe service. We also illustrate how a specialized mobility testing tool significantly simplifies the process of testing proximity-based semantics. We then present the implementation of Pervaho, which is based on a set of communication protocols geared at mesh networks. Finally, we provide a performance analysis of our implementation.     

Meta-environment and executable meta-language using smalltalk: an experience report

Object-oriented modelling languages such as EMOF are often used to specify domain specific meta-models. However, these modelling languages lack the ability to describe behavior or operational semantics. Several approaches have used a subset of Java mixed with OCL as executable meta-languages. In this experience report we show how we use Smalltalk as an executable meta-language in the context of the Moose reengineering environment. We present how we implemented EMOF and its behavioral aspects. Over the last decade we validated this approach through incrementally building a meta-described reengineering environment. Such an approach bridges the gap between a code-oriented view and a meta-model driven one. It avoids the creation of yet another language and reuses the infrastructure and run-time of the underlying implementation language. It offers an uniform way of letting developers focus on their tasks while at the same time allowing them to meta-describe their domain model. The advantage of our approach is that developers use the same tools and environment they use for their regular tasks. Still the approach is not Smalltalk specific but can be applied to language offering an introspective API such as Ruby, Python, CLOS, Java and C#.

Dialogue seminars as a tool in post graduate education

This paper describes and discusses a new postgraduate course based on the dialogue-seminar method. The course and the method have been developed within the research area of skill and technology, based at the Royal Institute of Technology in Stockholm. The main features of the course were dialogue and reflection on practice of research inspired by reading of the source texts from the history of science and philosophy written by: Descartes, Leibniz, Diderot, D’Alembert, Gadamer, Galileo and Darwin. The concept of liberal education was of importance in the design of the course. Doctoral students were all adults interested in applying of research in order to improve practices at their own work places. Funds for this project were granted by the Swedish Council for the Renewal of Higher Education.

---

Offline variants of the “lion and man” problem: —Some problems and techniques for measuring crowdedness and for safe path planning—

Consider the following safe path planning problem: Given a set of trajectories (paths) of k point robots with maximum unit speed in a bounded region over a (long) time interval [0,T], find another trajectory (if it exists) subject to the same maximum unit speed limit, that avoids (that is, stays at a safe distance of) each of the other k trajectories over the entire time interval. We call this variant the continuous model of the safe path planning problem. The discrete model of this problem is: Given a set of trajectories (paths) of k point robots in a graph over a (long) time interval 0,1,2,…,T, find a trajectory (path) for another robot, that avoids each of the other k at any time instant in the given time interval.We introduce the notions of the avoidance number of a region, and that of a graph, respectively, as the maximum number of trajectories which can be avoided in the region (respectively, graph). We give the first estimates on the avoidance number of the n×n grid G_n, and also devise an efficient algorithm for the corresponding safe path planning problem in arbitrary graphs. We then show that our estimates on the avoidance number of G_n can be extended for the avoidance number of a bounded (fat) region. In the final part of our paper, we consider other related offline questions, such as the maximum number of men problem and the spy problem.     

Nebelung: Execution Environment for Transactional OpenMP

Future generations of Chip Multiprocessors (CMP) will provide dozens or even hundreds of cores inside the chip. Writing applications that benefit from the massive computational power offered by these chips is not going to be an easy task for mainstream programmers who are used to sequential algorithms rather than parallel ones. This paper explores the possibility of using Transactional Memory (TM) in OpenMP, the industrial standard for writing parallel programs on shared-memory architectures, for C, C++ and Fortran. One of the major complexities in writing OpenMP applications is the use of critical regions (locks), atomic regions and barriers to synchronize the execution of parallel activities in threads. TM has been proposed as a mechanism that abstracts some of the complexities associated with concurrent access to shared data while enabling scalable performance. The paper presents a first proof-of-concept implementation of OpenMP with TM. Some language extensions to OpenMP are proposed to express transactions. These extensions are implemented in our source-to-source OpenMP Mercurium compiler and our Software Transactional Memory (STM) runtime system Nebelung that supports the code generated by Mercurium. Hardware Transactional Memory (HTM) or Hardware-assisted STM (HaSTM) are seen as possible paths to make the tandem TM-OpenMP more scalable. In the evaluation section we show the preliminary results. The paper finishes with a set of open issues that still need to be addressed, either in OpenMP or in the hardware/software implementations of TM.     

Progressive Transient Photon Beams

In this work, we introduce a novel algorithm for transient rendering in participating media. Our method is consistent, robust and is able to generate animations of time‐resolved light transport featuring complex caustic light paths in media. We base our method on the observation that the spatial continuity provides an increased coverage of the temporal domain, and generalize photon beams to transient‐state. We extend stead‐state photon beam radiance estimates to include the temporal domain. Then, we develop a progressive variant of our approach which provably converges to the correct solution using finite memory by averaging independent realizations of the estimates with progressively reduced kernel bandwidths. We derive the optimal convergence rates accounting for space and time kernels, and demonstrate our method against previous consistent transient rendering methods for participating media.