Srdjan Skrbic

CUDA programs for solving the time-dependent dipolar Gross-Pitaevskii equation in an anisotropic trap

In this paper we present new versions of previously published numerical programs for solving the dipolar Gross–Pitaevskii (GP) equation including the contact interaction in two and three spatial dimensions in imaginary and in real time, yielding both stationary and non-stationary solutions. New versions of programs were developed using CUDA toolkit and can make use of Nvidia GPU devices. The algorithm used is the same split-step semi-implicit Crank–Nicolson method as in the previous version (Kishor Kumar et al., 2015), which is here implemented as a series of CUDA kernels that compute the solution on the GPU. In addition, the Fast Fourier Transform (FFT) library used in the previous version is replaced by cuFFT library, which works on CUDA-enabled GPUs. We present speedup test results obtained using new versions of programs and demonstrate an average speedup of 12–25, depending on the program and input size.

Prioritized fuzzy logic based information processing in relational databases

Many years of research related to fuzzy logic and fuzzy set theory extensions to relational databases have not lead to stable implementations, standardized languages or fuzzy relational database application development tools and methods. The main goal of this paper is the modelling and the implementation of a set of tools that allow usage of fuzzy logic enriched with priorities in relational database applications. In order to achieve that goal, at first, the relational data model is extended with the elements of fuzzy set theory. After that, a fuzzy extension of the SQL query language, called the PFSQL, is defined. An interpreter for that language is integrated inside an implementation of the fuzzy JDBC driver. An implementation of the CASE tool for modelling of fuzzy relational database schemas rounds up a set of tools for the implementation of Java fuzzy database applications. In this sense, this paper presents a step towards a methodology for the fuzzy relational database application development.

OpenMP, OpenMP/MPI, and CUDA/MPI C programs for solving the time-dependent dipolar Gross–Pitaevskii equation

We present new versions of the previously published C and CUDA programs for solving the dipolar Gross–Pitaevskii equation in one, two, and three spatial dimensions, which calculate stationary and non-stationary solutions by propagation in imaginary or real time. Presented programs are improved and parallelized versions of previous programs, divided into three packages according to the type of parallelization. First package contains improved and threaded version of sequential C programs using OpenMP. Second package additionally parallelizes three-dimensional variants of the OpenMP programs using MPI, allowing them to be run on distributed-memory systems. Finally, previous three-dimensional CUDA-parallelized programs are further parallelized using MPI, similarly as the OpenMP programs. We also present speedup test results obtained using new versions of programs in comparison with the previous sequential C and parallel CUDA programs. The improvements to the sequential version yield a speedup of 1.1–1.9, depending on the program. OpenMP parallelization yields further speedup of 2–12 on a 16-core workstation, while OpenMP/MPI version demonstrates a speedup of 11.5–16.5 on a computer cluster with 32 nodes used. CUDA/MPI version shows a speedup of 9–10 on a computer cluster with 32 nodes.

Parallelization of Minimum Spanning Tree Algorithms Using Distributed Memory Architectures

Finding a minimum spanning tree of a graph is a well known problem in graph theory with many practical applications. We study serial variants of Prim’s and Kruskal’s algorithm and present their parallelization targeting message passing parallel machine with distributed memory. We consider large graphs that can not fit into memory of one process. Experimental results show that Prim’s algorithm is a good choice for dense graphs while Kruskal’s algorithm is better for sparse ones. Poor scalability of Prim’s algorithm comes from its high communication cost while Kruskal’s algorithm showed much better scaling to larger number of processes.

Formalising pfsql queries using ŁΠ fuzzy logic

Using the concept of a generalised priority constraint satisfaction problem, we previously found a way to introduce priority queries into fuzzy relational databases. The results were PFSQL (Priority Fuzzy Structured Query Language) together with a database independent interpreter for it. In an effort to improve the performance of the resolution of PFSQL queries, the aim of the current paper is to formalise PFSQL queries by obtaining their interpretation in an existing fuzzy logic. We have found that the ŁI logic provides sufficient elements. The SELECT line of PFSQL queries is semantically a formula of some fuzzy logic, and we show that such formulas can be naturally expressed in a conservative extension of the ŁI logic. Furthermore, we prove a theorem that gives the PSPACE containment for the complexity of finding a model for a given ŁI logic formula.

Comparing priority, weighted and queries with threshold in PFSQL

PFSQL is the query language used for querying fuzzy relational databases. One of the most recognizable features of PFSQL is the possibility to prioritize conditions. Priorities are most often confused with weights. In this paper we compare queries with prioritized conditions with queries with weighed conditions. Since PFCSP systems are the theoretical background for PFSQL and similarly WFCSP are the theoretical background for weighted queries we elaborate these two systems. Queries with thresholds are another feature of PFSQL. When a threshold is attached to a condition only the tuples that satisfy the condition with a higher value then the threshold are displayed in the result. Through examples we compare these features of PFSQL.

Towards the High Performance Method for Large-Scale Electronic Structure Calculations

Density functional theory is a method for calculation of electronic structure of physical systems with a large number of atoms. In an effort to produce parallel implementation capable of solving systems with tens of thousands of atoms, in the first steps, we use Gaussian orbitals that allow relevant integrals to be calculated analytically. The main goal of this paper is the serial implementation of these integral calculations using C programming language. The analytical solutions consist of a very complex nested summations whose efficient implementation is the main contribution of this paper. We describe challenges encountered during implementation and their solutions. Results show that the given C implementation is at least three orders of magnitude faster than numerical solutions in the best available computational software programs.

GPFCSP Systems: Definition and Formalization

The aim of this paper is to construct a General Prioritized Fuzzy Satisfaction Problem (GPFCSP) that can handle any logical expression whose atomic symbols are prioritized constraints. GPFCSP can be applied in the field of Fuzzy Relational Databases, multilateral negotiations, decision making etc. The interpretation method is used in order to obtain a complete axiomatization.

Parallel implementation of minimum spanning tree algorithms using MPI

In this paper we study parallel algorithms for finding minimum spanning tree of a graph. We present two algorithms, based on sequential algorithms of Prim and Kruskal, targeting message passing parallel machine with distributed memory. First algorithm runs in O(n2=p+n log p) and second algorithm runs in O(n2=p + n2 log p).

Generalised Prioritised Fuzzy Constraint Satisfaction Problem

The aim of this paper is to introduce, define and illustrate Generalised Prioritised Fuzzy Constraint Satisfaction Problem (GPFCSP). First, basic notions and historical background will be given, then the definition and finally one example of GPFCSP is explained.