A Formal Design of a Tool for Static Analysis of Upper Bounds on Object Calls in Java

Abstract. This paper presents a formal design of a tool for statically establishing the upper bound on the number of executions of objects’ methods in a fragment of object-oriented code. The algorithm that our tool employs is a multi-pass interprocedural analysis consisting of data flow and region-based analyses. We describe the formalization of each of stage of the algorithm. This rigorous specification greatly aids the implementation of the tool by removing ambiguities of textual descrip-tions. There are many applications for information obtained through this method including reasoning about concurrent code, scheduling, code optimization, compositing services, etc.We concentrate on using upper bounds to instrument transactional code that uses a synchronization mechanism based on versioning, and therefore benefits from a priori knowledge about the usage of shared objects within each transaction. To this end we implement a precompiler for Java that analyzes transac-tions, and injects generated source code to initialize each transaction

Part-based 3D object retrieval via multi-label optimization

This paper deals with the problem of 3D object retrieval using a part-based representation. The premise in this context is that similar objects will consist of similar parts. A part-based representation is proposed, where each object is segmented, and represented as a labeled graph, with nodes corresponding to parts, and edges connecting adjacent parts. The calculation of the distance between two segmented objects is formulated as a multi-label optimization problem, taking into account the aforementioned graphs. The proposed method achieves comparable performance to the state-of-the-art on several datasets, while it has a clear advantage in the case of articulated objects. © 2017 Elsevier Inc

A comprehensive overview of methodologies and performance evaluation frameworks in 3D mesh segmentation

3D mesh segmentation has become a crucial part of many applications in 3D shape analysis. In this paper, a comprehensive survey on 3D mesh segmentation methods is presented. Analysis of the existing methodologies is addressed taking into account a new categorization along with the performance evaluation frameworks which aim to support meaningful benchmarks not only qualitatively but also in a quantitative manner. This survey aims to capture the essence of current trends in 3D mesh segmentation. © 2015 Elsevier Inc. All rights reserved

Unsupervised Spectral Mesh Segmentation Driven by Heterogeneous Graphs

A fully automatic mesh segmentation scheme using heterogeneous graphs is presented. We introduce a spectral framework where local geometry affinities are coupled with surface patch affinities. A heterogeneous graph is constructed combining two distinct graphs: A weighted graph based on adjacency of patches of an initial over-segmentation, and the weighted dual mesh graph. The partitioning relies on processing each eigenvector of the heterogeneous graph Laplacian individually, taking into account the nodal set and nodal domain theory. Experiments on standard datasets show that the proposed unsupervised approach outperforms the state-of-The-Art unsupervised methodologies and is comparable to the best supervised approaches. © 1979-2012 IEEE

A Review on 3D Object Retrieval Methodologies Using a Part-Based Representation

ABSTRACT: A comprehensive overview of 3D Object Retrieval methodologies that use a part-based representation is presented. Taking into account the typical operational pipeline we detail each distinct module and we provide a comparative study between the individual modules as well as the global methodologies. This study relies upon the 3D mesh segmentation scheme used, the feature extraction method chosen, as well as the selected graph matching methodology. © 2014, © 2014 CAD Solutions, LLC

A Programming Model for Deterministic Task Parallelism

Abstract The currently dominant programming models to write software for multicore processors use threads that run over shared memory. However, as the core count increases, cache coherency protocols get very complex and ineffective, and maintaining a shared memory abstraction becomes expensive and impractical. Moreover, writing multithreaded programs is notoriously difficult, as the programmer needs to reason about all the possible thread interleavings and interactions, including the myriad of implicit, non-obvious, and often unpredictable thread interactions through shared memory. Overall, as processors get more cores and parallel software becomes mainstream, the shared memory model reaches its limits regarding ease of programming and efficiency. This position paper presents two ideas aiming to solve the problem. First, we restrict the way the programmer expresses parallelism: The program is a collection of possibly recursive tasks, where each task is atomic and cannot communicate with any other task during its execution. Second, we relax the requirement for coherent shared memory: Each task defines its memory footprint, and is guaranteed to have exclusive access to that memory during its execution. Using this model, we can then define a runtime system that transparently performs the data transfers required among cores without cache coherency, and also produces a deterministic execution of the program, provably equivalent to its sequential elision