pinecone/core-2020-05-10-deduplication huggingface dataset:
A multi-level hypergraph partitioning algorithm using rough set clustering.

The hypergraph partitioning problem has many applications in scientific computing and provides a more accurate inter-processor communication model for distributed systems than the equivalent graph problem. In this paper, we propose a sequential multi-level hypergraph partitioning algorithm. The algorithm makes novel use of the technique of rough set clustering in categorising the vertices of the hypergraph. The algorithm treats hyperedges as features of the hypergraph and tries to discard unimportant hyperedges to make better clustering decisions. It also focuses on the trade-off to be made between local vertex matching decisions (which have low cost in terms of the space required and time taken) and global decisions (which can be of better quality but have greater costs). The algorithm is evaluated and compared to state-of-the-art algorithms on a range of benchmarks. The results show that it generates better partition quality
Runtime-aware architectures

In the last few years, the traditional ways to keep the increase of hardware performance to the rate predicted by the Moore’s Law have vanished. When uni-cores were the norm, hardware design was decoupled from the software stack thanks to a well defined Instruction Set Architecture (ISA). This simple interface allowed developing applications without worrying too much about the underlying hardware, while hardware designers were able to aggressively exploit instruction-level parallelism (ILP) in superscalar processors. Current multi-cores are designed as simple symmetric multiprocessors (SMP) on a chip. However, we believe that this is not enough to overcome all the problems that multi-cores face. The runtime system of the parallel programming model has to drive the design of future multi-cores to overcome the restrictions in terms of power, memory, programmability and resilience that multi-cores have. In the paper, we introduce an approach towards a Runtime-Aware Architecture (RAA), a massively parallel architecture designed from the runtime’s perspective.This work has been partially supported by the European Research Council under the European Union’s 7th FP, ERC Grant Agreement number 321253, by the Spanish Ministry of Science and Innovation under grant TIN2012-34557 and by the HiPEAC Network of Excellence. M. Moreto has been partially supported by the Ministry of Economy and Competitiveness under Juan de la Cierva postdoctoral fellowship number JCI- 2012-15047, and M. Casas is supported by the Secretary for Universities and Research of the Ministry of Economy and Knowledge of the Government of Catalonia and the Co-fund programme of the Marie Curie Actions of the 7th R&D Framework Programme of the European Union (Contract 2013 BP B 00243).Peer ReviewedPostprint (author's final draft
Automatic Data Layout Optimizations for GPUs

Memory optimizations have became increasingly important in order to fully exploit the computational power of modern GPUs. The data arrangement has a big impact on the performance, and it is very hard for GPU programmers to identify a well-suited data layout. Classical data layout transformations include grouping together data fields that have similar access patterns, or transforming Array-of-Structures (AoS) to Structure-of-Arrays (SoA).
This paper presents an optimization infrastructure to automatically determine an improved data layout for OpenCL programs written in AoS layout. Our framework consists of two separate algorithms: The first one constructs a graph-based model, which is used to split the AoS input struct into several clusters of fields, based on hardware dependent parameters. The second algorithm selects a good per-cluster data layout (e.g., SoA, AoS or an intermediate layout) using a decision tree. Results show that the combination of both algorithms is able to deliver higher performance than the individual algorithms. The layouts proposed by our framework result in speedups of up to 2.22, 1.89 and 2.83 on an AMD FirePro S9000, NVIDIA GeForce GTX 480 and NVIDIA Tesla k20m, respectively, over different AoS sample programs, and up to 1.18 over a manually optimized program
Software consolidation as an efficient energy and cost saving solution for a SaaS/PaaS cloud model

Virtual machines (VM) are used in cloud computing environments to isolate different software. Virtualization enables live migration, and thus dynamic VM consolidation. This possibility can be used to reduce power consumption in the cloud. However, consolidation in cloud environments is limited due to reliance on VMs, mainly due to their memory overhead. For instance, over a 4-month period in a real cloud located in Grenoble (France), we observed that 805 VMs used less than 12 % of the CPU (of the active physical machines). This paper presents a solution introducing dynamic software consolidation. Software consolidation makes it possible to dynamically collocate several software applications on the same VM to reduce the number of VMs used. This approach can be combined with VM consolidation which collocates multiple VMs on a reduced number of physical machines. Software consolidation can be used in a private cloud to reduce power consumption, or by a client of a public cloud to reduce the number of VMs used, thus reducing costs. The evaluation was performed using both the SPECjms2007 benchmark and an enterprise LAMP benchmark on both a VMware private cloud and Amazon EC2 public cloud. The results show that our approach can reduce the energy consumed in our private cloud by about 40 % and the charge for VMs on Amazon EC2 by about 40.5 %
Leveraging MPI-3 Shared-Memory Extensions for Efficient PGAS Runtime
  Systems

The relaxed semantics and rich functionality of one-sided communication
primitives of MPI-3 makes MPI an attractive candidate for the implementation of
PGAS models. However, the performance of such implementation suffers from the
fact, that current MPI RMA implementations typically have a large overhead when
source and target of a communication request share a common, local physical
memory. In this paper, we present an optimized PGAS-like runtime system which
uses the new MPI-3 shared-memory extensions to serve intra-node communication
requests and MPI-3 one-sided communication primitives to serve inter-node
communication requests. The performance of our runtime system is evaluated on a
Cray XC40 system through low-level communication benchmarks, a random-access
benchmark and a stencil kernel. The results of the experiments demonstrate that
the performance of our hybrid runtime system matches the performance of
low-level RMA libraries for intra-node transfers, and that of MPI-3 for
inter-node transfers.Comment: 12 papers, accepted for publication in EuroPar 201
MPI Thread-Level Checking for MPI+OpenMP Applications

International audienceMPI is the most widely used parallel programming model. But the reducing amount of memory per compute core tends to push MPI to be mixed with shared-memory approaches like OpenMP. In such cases, the interoperability of those two models is challenging. The MPI 2.0 standard defines the so-called thread level to indicate how MPI will interact with threads. But even if hybrid programs are more common, there is still a lack in debugging tools and more precisely in thread level compliance. To fill this gap, we propose a static analysis to verify the thread-level required by an application. This work extends PARCOACH, a GCC plugin focused on the detection of MPI collective errors in MPI and MPI+OpenMP programs. We validated our analysis on computational benchmarks and applications and measured a low overhead
From tele-operated robots to social robots with autonomous behaviors

This paper presents a perception/interface device for Telepresence Mobile Robots using a Kinect sensor. Firstly, using the Kinect RGB camera (Webcam) and image processing techniques, it is possible to detect a human face, allowing the robot to track the face, getting closer of a person, moving forward and rotating to get a better pose (position and orientation) to interact with him/her. Then it is possible to recognize hand gestures using the Kinect 3D sensor (Depth camera). The proposed gesture recognition method tracks the hands positions and movements, when moving it forward towards the robot, and then recognizing a set of predefined gestures/commands. Finally, the 3D perception provided by the Kinect also allows us to detect obstacles, avoiding collisions and safely moving the mobile robot base, also allowing to search for someone in the environment. Practical experiments are presented demonstrating the obtained results: (i) in the searching and tracking of human faces; (ii) in the robot positioning related to the user we want to interact with; and also (iii) in the human gesture recognition.CAPES/D
Automatic semantic waypoint mapping applied to autonomous vehicles

Road network maps have been used for autonomous vehicle\ud
path planning. These maps are basically formed by GPS waypoints\ud
and can contain semantic information about the environment to help\ud
following traffic codes. This paper describes a novel method for automatic\ud
construction of a waypoint map containing semantic information\ud
about roads. The collected GPS points are stored into flexible waypoint\ud
data structures that can represent any relevant information for vehicle\ud
navigation. The mapping method also reduces the amount of waypoints\ud
by recognizing and converting them into traffic structures. The resulting\ud
waypoint map is stored in a text file which is both human and machinereadable.\ud
This work makes part of CaRINA II platform, an autonomous\ud
vehicle under development by the Mobile Robotics Laboratory (LRM) -\ud
ICMC/USP. Tests were conducted in urban environment and the resulting\ud
maps were consistent when compared to publicly available satellite\ud
maps.FAPESP (processo nº. 10 / 01305-1 e 12 / 02354-1)CNPq (processo nº. 158.581 / 2013-0
RoboSeT: a tool to support cataloging and discovery of services for service-oriented robotic systems

Robotics has played an increasingly important role in\ud
several sectors of the society. Nowadays, robots are not only used to\ud
support activities in factories, but also to assist house cleaning, border\ud
surveillance, and even surgeries. The variety of application domains and\ud
the rising complexity are challenging the design of robotic systems that\ud
control such robots. In this perspective, Service-Oriented Architecture\ud
(SOA) has been adopted as a promising architectural style to design\ud
large, complex robotic systems in a flexible and reusable manner. Several\ud
Service-Oriented Robotic Systems (SORS) have been developed in\ud
the recent years and a large number of services are available for reuse.\ud
Nevertheless, none of the environments dedicated to the development of\ud
SORS provide an efficient mechanism for publishing and discovering services.\ud
As a consequence, services for SORS have to be manually searched,\ud
reducing significantly the potential of reuse and productivity provided\ud
by SOA. This paper presents RoboSeT, a mechanism that supports cataloging\ud
and discovery of services for robotic systems. RoboSeT is based\ud
on semantic search and classifies the services using a taxonomy of the\ud
robotics domain. Results of our case study indicate that RoboSeT facilitates\ud
the development of robotic systems, since it presents the potential\ud
to widely promote reusability of services for SORSCNPq – (Grant. No.: 2011/23316-8)Capes – (Grant. No.: 2011/06022-0)FAPESP (Grant. No.: 2014/02244-7)National Science and Technology Institute for Critical Embedded Systems – INCT-SEC (Grant N.: 573963/2008-8 and 2008/57870-9
Complexity and algorithms for finding a perfect phylogeny from mixed
  tumor samples

Recently, Hajirasouliha and Raphael (WABI 2014) proposed a model for
deconvoluting mixed tumor samples measured from a collection of high-throughput
sequencing reads. This is related to understanding tumor evolution and critical
cancer mutations. In short, their formulation asks to split each row of a
binary matrix so that the resulting matrix corresponds to a perfect phylogeny
and has the minimum number of rows among all matrices with this property. In
this paper we disprove several claims about this problem, including an
NP-hardness proof of it. However, we show that the problem is indeed NP-hard,
by providing a different proof. We also prove NP-completeness of a variant of
this problem proposed in the same paper. On the positive side, we propose an
efficient (though not necessarily optimal) heuristic algorithm based on
coloring co-comparability graphs, and a polynomial time algorithm for solving
the problem optimally on matrix instances in which no column is contained in
both columns of a pair of conflicting columns. Implementations of these
algorithms are freely available at
https://github.com/alexandrutomescu/MixedPerfectPhylogenyComment: This is the extended version of Hujdurovi\'c et al, Finding a perfect
  phylogeny from mixed tumor samples, WABI 2015, DOI:
  10.1007/978-3-662-48221-6_
A simple abstraction of arrays and maps by program translation

International audienceWe present an approach for the static analysis of programs handling arrays, with a Galois connection between the semantics of the array program and semantics of purely scalar operations. The simplest way to implement it is by automatic, syntactic transformation of the array program into a scalar program followed analysis of the scalar program with any static analysis technique (abstract interpretation, acceleration, predicate abstraction,.. .). The scalars invariants thus obtained are translated back onto the original program as universally quantified array invariants. We illustrate our approach on a variety of examples, leading to the " Dutch flag " algorithm
Parallel Cost Analysis of Distributed Systems

We present a novel static analysis to infer the parallel cost of distributed systems. Parallel cost differs from the standard notion of serial cost by exploiting the truly concurrent execution model of distributed processing to capture the cost of synchronized tasks executing in parallel. It is challenging to analyze parallel cost because one needs to soundly infer the parallelism between tasks while accounting for waiting and idle processor times at the different locations. Our analysis works in three phases: (1) It first performs a block-level analysis to estimate the serial costs of the blocks between synchronization points in the program; (2) Next, it constructs a distributed ow graph (DFG) to capture the parallelism, the waiting and idle times at the locations of the distributed system; Finally, (3) the parallel cost can be obtained as the path of maximal cost in the DFG. A prototype implementation demonstrates the accuracy and feasibility of the proposed analysis
A Forward Analysis for Recurrent Sets

Non-termination of structured imperative programs is primarily due to infinite loops. An important class of non-terminating loop behaviors can be characterized using the notion of recurrent sets. A recurrent set is a set of states from which execution of the loop cannot or might not escape. Existing analyses that infer recurrent sets to our knowledge rely on one of: the combination of forward and backward analyses, quantifier elimination, or SMT-solvers. We propose a purely forward abstract interpretation–based analysis that can be used together with a possibly complicated abstract domain where none of the above is readily available. The analysis searches for a recurrent set of every individual loop in a program by building a graph of abstract states and analyzing it in a novel way. The graph is searched for a witness of a recurrent set that takes the form of what we call a recurrent component which is somewhat similar to the notion of an end component in a Markov decision process.A. Bakhirkin is supported by a Microsoft Research PhD Scholarship.Peer-reviewedPost-print22nd International Symposium, STATIC ANALYSIS SYMPOSIUM (SAS) 2015, Saint-Malo, Franc
May-Happen-in-Parallel Analysis for\ud
Asynchronous Programs with Inter-Procedural\ud
Synchronization

A may-happen-in-parallel (MHP) analysis computes pairs of program points that may execute in parallel across different distributed components. This information has been proven to be essential to infer both safety properties (e.g., deadlock freedom) and liveness  properties  termination and resource boundedness) of asynchronous programs. Existing MHP analyses take advantage of the synchronization points to learn that one task has finished and thus will not happen in parallel with other tasks that are still active. Our starting point is an existing MHP analysis developed for intra-procedural synchronization, i.e., it only allows synchronizing with tasks that have been spawned inside the current task. This paper leverages such MHP analysis to handle inter-procedural synchronization, i.e., a task spawned by one task can be awaited within a different task. This is challenging because task synchronization goes beyond the boundaries of methods, and thus the inference of MHP relations requires novel extensions to capture inter-procedural dependencies. The analysis has been implemented and it can be tried online
Sociomateriality Implications of Software As a Service Adoption on IT-workers’ Roles and Changes in Organizational Routines of IT Systems Support

This paper aims to deepen our understanding on how sociomateriality practices influence IT
workers’ roles and skill set requirements and changes to the organizational routines of IT systems support,
when an organization migrates an on-premise IT system to a software as a service (SaaS) model. This
conceptual paper is part of an ongoing study investigating organizations that migrated on-premise IT email
systems to SaaS business models, such as Google Apps for Education (GAE) and Microsoft Office 365
systems, in New Zealand tertiary institutions. We present initial findings from interpretive case studies. The
findings are, firstly, technological artifacts are entangled in sociomaterial practices, which change the way
humans respond to the performative aspects of the organizational routines. Human and material agencies are
interwoven in ways that reinforce or change existing routines. Secondly, materiality, virtual realm and spirit
of the technology provide elementary levels at which human and material agencies entangle. Lastly, the
elementary levels at which human and material entangle depends on the capabilities or skills set of an
individual
Accelerating LTV based homomorphic encryption in reconfigurable hardware

After being introduced in 2009, the first fully homomorphic encryption (FHE) scheme has created significant excitement in academia and industry. Despite rapid advances in the last 6 years, FHE schemes are still not ready for deployment due to an efficiency bottleneck. Here we introduce a custom hardware accelerator optimized for a class of reconfigurable logic to bring LTV based somewhat homomorphic encryption (SWHE) schemes one step closer to deployment in real-life applications. The accelerator we present is connected via a fast PCIe interface to a CPU platform to provide homomorphic evaluation services to any application that needs to support blinded computations. Specifically we introduce a number theoretical transform based multiplier architecture capable of efficiently handling very large polynomials. When synthesized for the Xilinx Virtex 7 family the presented architecture can compute the product of large polynomials in under 6.25 msec making it the fastest multiplier design of its kind currently available in the literature and is more than 102 times faster than a software implementation. Using this multiplier we can compute a relinearization operation in 526 msec. When used as an accelerator, for instance, to evaluate the AES block cipher, we estimate a per block homomorphic evaluation performance of 442 msec yielding performance gains of 28.5 and 17 times over similar CPU and GPU implementations, respectively
On Computing the Hyperbolicity of Real-World Graphs

International audienceThe (Gromov) hyperbolicity is a topological property of a graph, which has been recently applied in several different contexts, such as the design of routing schemes, network security, computational biology, the analysis of graph algorithms, and the classification of complex networks. Computing the hyperbolicity of a graph can be very time consuming: indeed, the best available algorithm has running-time O(n^{3.69}), which is clearly prohibitive for big graphs. In this paper, we provide a new and more efficient algorithm: although its worst-case complexity is O(n^4), in practice it is much faster, allowing, for the first time, the computation of the hyperbolicity of graphs with up to 200,000 nodes. We experimentally show that our new algorithm drastically outperforms the best previously available algorithms, by analyzing a big dataset of real-world networks. Finally, we apply the new algorithm to compute the hyperbolicity of random graphs generated with the Erdös-Renyi model, the Chung-Lu model, and the Configuration Model
Exact Minkowski Sums of Polygons With Holes

We present an efficient algorithm that computes the Minkowski sum of two
polygons, which may have holes. The new algorithm is based on the convolution
approach. Its efficiency stems in part from a property for Minkowski sums of
polygons with holes, which in fact holds in any dimension: Given two polygons
with holes, for each input polygon we can fill up the holes that are relatively
small compared to the other polygon. Specifically, we can always fill up all
the holes of at least one polygon, transforming it into a simple polygon, and
still obtain exactly the same Minkowski sum. Obliterating holes in the input
summands speeds up the computation of Minkowski sums.
  We introduce a robust implementation of the new algorithm, which follows the
Exact Geometric Computation paradigm and thus guarantees exact results. We also
present an empirical comparison of the performance of Minkowski sum
construction of various input examples, where we show that the implementation
of the new algorithm exhibits better performance than several other
implementations in many cases. In particular, we compared the implementation of
the new algorithm, an implementation of the standard convolution algorithm, and
an implementation of the decomposition approach using various convex
decomposition methods, including two new methods that handle polygons with
holes - one is based on vertical decomposition and the other is based on
triangulation.
  The software has been developed as an extension of the "2D Minkowski Sums"
package of CGAL (Computational Geometry Algorithms Library). Additional
information and supplementary material is available at our project page
http://acg.cs.tau.ac.il/projects/rcComment: 13 pages, 7 figures. Submitted to ESA 201