This paper analyzes three different classes of graphs to experimentally determine the classes for which the label propagation algorithm never converges and possible cycle lengths that can occur. The label propagation algorithm has been widely used in social and complex network community detection, both because of its simplicity and nearly linear time complexity, which makes it applicable to extremely large networks. In its basic form, it has certain drawbacks. The most common problems are label oscillations, which occur in certain classes of complex networks, preventing the convergence of the algorithm. Oscillations are found to be rare for circulant and random graphs, but very common for bipartite graphs. No example of a cycle longer than two has been found using an exhaustive search method for graph sizes of up to 17 nodes.

The time complexity of algorithms is a critical concept in computer science and engineering, and it is recognized as a fundamental topic in the Association for Computing Machinery (ACM) curricular recommendations. In alignment with these guidelines, numerous universities worldwide incorporate this topic into their introductory computer science courses, which typically have large student enrollments annually. Consequently, there is an increasing demand for automation in both instructional and assessment processes. This study explores the potential of Large Language Models (LLMs) to assist teaching staff in generating source code segments with predefined time complexity and determining the time complexity of given code segments, with applications in educational and examination contexts. We proposed a novel methodology for LLM evaluation in the aforementioned context and evaluated three prominent LLMs: ChatGPT, Gemini, and Llama, on their ability to generate and analyze C code segments exhibiting linear, logarithmic, quadratic, and exponential time complexities. A framework was developed to automate the prompt and segment generation and time complexity determination using two mainstream prompt engineering methods: zero-shot and chain-of-thought, and assessed the differences in code generation and time complexity analysis. A total of 960 generated segments were assessed on the correctness of time complexity, structural appropriateness, and suitability for exam use. The results suggest that ChatGPT is the most suitable LLM for generating segments with predefined time complexity (success rate goes up to 61%). All LLMs yielded the best results in generating linear segments, while exponential complexity posed the greatest challenge overall. A subset of generated segments was extracted to evaluate the time complexity determination capabilities. All three LLMs were asked to find the time complexity of each extracted segment. The most accurate LLM is ChatGPT (79.6%). We also assessed how good each LLM is in determining the time complexity of segments generated by itself. Llama outperforms others in that task (83% of successful determinations) when the zero-shot prompt method is used. The findings suggest that current LLMs cannot fully automate question generation and time complexity problem solving. However, they can substantially support the process and reduce the workload for educators.

Large numbers of small tensor kernels are executed by GPUs in modern deep learning frameworks, where total performance is frequently constrained by memory bandwidth and kernel launch overheads. Systems such as TensorFlow XLA, PyTorch JIT, and cuDNN often use kernel fusion, which is defined as combining many tensor operations into a single GPU kernel, to reduce intermediate memory transfers and boost efficiency. Nevertheless, it is difficult to measure the true performance impact of fusion on both isolated tensor operations and end-to-end model execution. An experimental investigation of kernel fusion on three different NVIDIA GPUs is presented in this work. For four sample tensor operations: element-wise addition, fused multiply-add, linear transformation with ReLU activation, and map-reduce, we build fused and unfused CUDA kernels using FP32, FP16, and mixed-precision arithmetics. We measure execution time, speedup, and effective memory bandwidth across a range of input sizes. For memory-bound and activation-heavy workloads, fusion yields consistent speedups between 1.5 & times; and 3.13 & times;, particularly for small and medium inputs where kernel launch overhead is significant. For operations dominated by atomic updates, the benefit is limited to between 1.01 & times; and 1.44 & times;. When the reduction strategy is reformulated using block-level shared-memory aggregation, kernel fusion becomes effective again, achieving speedups of up to 2 & times; by eliminating global synchronization bottlenecks. We further evaluate the effect of fusion on image classification models using PyTorch 2.10.0 JIT, achieving 1.54 & times; to 1.83 & times; faster inference. Our results provide practical guidelines on when kernel fusion is most effective.

U poslednje dve decenije, bioinformatika se razvila u važnu naučnu oblast koja spaja biološke podatke i informacione tehnologije kako bi rešavala složene biološke i medicinske probleme. U vezi sa tim postoji značajan rast potražnja za stručnjacima u ovoj oblasti. Prateći taj trend, akademski institucije širom sveta prilagođavaju svoje kurikulume zahtevima tržišta rada, nastojeći da usklade osnovna znanja, računarske veštine i interdisciplinarni pristup. U okviru ovog rada se ispituju master programi bioinformatike na univerzitetima širom sveta, analizirajući kompetencije, strukturu kurikuluma, nastavne metode i praktičan rad. Rezultati pokazuju značajne razlike među postojećim programima, s posebnim naglaskom na projektno učenje, praktičnu primenu i povezivanje sa industrijom i kliničkom praksom. Ovi nalazi predstavljaju temelj za kreiranje novog master programa bioinformatike u Srbiji, koji bi kombinovao najbolje globalne prakse sa specifičnim lokalnim potrebama.

We present the results of experiments performed using ChatGPT versions 3.5 and 4o to explore the possibilities of generating and solving exam questions related to the time complexity analysis of algorithms in programming courses. Both well-known and artificial code segments for educational purposes were observed. We concluded that ChatGPT can help automate exam question assembling and solving, but it is unreliable. We also observed that ChatGPT 4o is more descriptive and in some cases more successful in generating and solving test problems correctly.

The swift progress of various types of machine learning and deep learning models necessitated the development of computational performance benchmarks. This study provides a performance evaluation analysis of the classical machine and deep learning algorithms executed on two different hardware architectures: the central processing units (CPUs) and the graphics processing units (GPUs). The experiments include various models such as linear regression, support vector machines, random forests, convolutional neural networks, and others. In this comparative analysis, the training and inference time are assessed. Additionally, trade-offs between CPU and GPU execution are presented. The results provide a set of recommendations for informed selection of optimal hardware for different machine learning models. It can serve as a guide for practitioners with a goal of enhancing the efficiency of their classical machine and deep learning models.

Large language models have sparked a lot of attention in the research community in recent days, especially with the introduction of practical tools such as ChatGPT and Github Copilot. Their ability to solve complex programming tasks was also shown in several studies and commercial solutions increasing the interest in using them for software development in different fields. High performance computing is one of such fields, where parallel programming techniques have been extensively used to utilize raw computing power available in contemporary multicore and manycore processors. In this paper, we perform an evaluation of the ChatGPT and Github Copilot tools for OpenMP-based code parallelization using a proposed methodology. We used nine different benchmark applications which represent typical parallel programming workloads and compared their OpenMP-based parallel solutions produced manually and using ChatGPT and Github Copilot in terms of obtained speedup, applied optimizations, and quality of the solution. ChatGPT 3.5 and Github Copilot installed with Visual Studio Code 1.88 were used. We concluded that both tools can produce correct parallel code in most cases. However, performance-wise, ChatGPT can match manually produced and optimized parallel code only in simpler cases, as it lacks a deeper understanding of the code and the context. The results are much better with Github Copilot, where much less effort is needed to obtain correct and performant parallel solution.

New, efficient parallel paradigms and models have been one of the main focuses of the research community in the domain of high-performance computing and multiprocessing systems. It is especially emphasized with the rise of many-core processors, such as graphics processing units. The development of parallel applications for different multi-core and many-core architectures becomes even harder, as it is usually needed to maintain different codebases. In this paper, we evaluate Kokkos, a new high-level parallel programming model and framework aimed at developing portable parallel programs for different architectures. We evaluated it using five different benchmark applications on the CPU and compared the results with OpenMP counterparts. The results and experiences are discussed in the paper.

Single-cell RNA sequencing (scRNAseq) and spatial transcriptomics have emerged as a powerful tool for unraveling the heterogeneity of cell populations and understanding cellular dynamics at unprecedented resolution. However, analyzing scRNAseq and spatial data poses unique challenges due to their high dimensionality and inherent noise. In this paper, a comprehensive tutorial on incorporating practical single-cell and spatial transcriptomics analysis is presented using Scanpy in a bioinformatics course at the University of Belgrade, School of Electrical Engineering. Scanpy, a versatile Python toolkit, offers a wide range of functionalities for quality control, dimensionality reduction, clustering, and trajectory inference. Through lectures and hands-on exercises, students learn essential concepts and techniques, including working with annotated data objects, preprocessing scRNAseq data, performing dimensionality reduction using Principal Component Analysis and Uniform Manifold Approximation and Projection, conducting clustering analysis with the Leiden algorithm, and identifying marker genes for cell type annotation. By equipping students with these skills, we aim to empower the next generation of bioinformaticians to explore the complexities of single-cell and spatial transcriptomics data and advance our understanding of cellular biology.

Computational complexity analysis plays an essential part in the education of computer and software engineers. For that reason, it is carefully studied in programming courses, as well as in the algorithms and data structures courses. The number of students who learn programming is rapidly growing, but the number of teachers cannot keep up with that trend. Therefore, it is necessary to develop tools that can ease and accelerate the daily tasks of teachers, especially for learning purposes and in the context of automating the processes of exam preparation. We propose a novel template- and rule-based approach and a corresponding software system for assembling synthetic source code segments of defined time complexity. Based on the developed grammar, the system can produce source code segments with a broad scope of different time complexities while guaranteeing the complexity of the generated segment. The system can be used for generating questions for exams as it can assemble a large number of different code segments that can be given as questions that have similar difficulty levels. The system was evaluated both by human experts and ChatGPT tool.

Cache coherence protocols play an important role in multiprocessor systems. For that reason, interactive simulations and visualizations of such protocols are often presented and used in computer architecture courses. This paper presents a short guide to the development of interactive animations of cache coherence protocols using VivioJS environment. First, an overview of existing tools for the development of interactive simulations is given. Then we explain the choice of simulation framework, followed by the description of the Vivio system and its latest iteration, VivioJS. We give an overview of the modifications we made to cache coherence protocols simulations from previous Vivio framework implementations. In the end, we discuss the advantages and disadvantages of the mentioned framework, our experiences, and recommendations for further improvement.

Plants are crucial in providing sufficient food for the increasing global population. To be able to provide an appropriate amount of food, the maximization of agricultural output is needed while input needs to be minimized. For these purposes, plant phenotyping techniques, i.e., measuring and analyzing the physical and biochemical characteristics of plants, can be employed. One of the most essential indicators of the general health and development of the plant is the color, shape, and number of leaves. To analyze plant images and capture essential plant traits, various algorithms have been developed. However, one of the important challenges in developing these algorithms is the occlusion or overlapping of leaves and biomass. We present a solution for leaf counting in the presence of occlusion in the plant Arabidopsis thaliana that includes four different convolutional neural network architectures. Datasets from the Computer Vision Problems in Plant Phenotyping (CVPPP) 2017 challenge and Photon System Instruments were used. The results are discussed in detail and compared with the existing solutions. Results showed that our solutions for leaf counting are superior to the previous winners of the CVPPP challenges.

Heterogeneous architectures consisting of both central processing units and graphics processing units are common in contemporary computer systems. For that reason, several programming models have been developed to exploit available parallelism, such as low-level CUDA and OpenCL, and directive-based OpenMP and OpenACC. In this paper we explore and evaluate the applicability of OpenACC, which is a directive-based programming model for GPUs. We focus both on the performance and programming effort needed to parallelize the existing sequential algorithms for GPU execution. The evaluation is based on the benchmark suite Parboil, which consists of 11 different mini-applications from different scientific domains, both compute- and memory-bound. The results show that mini-apps parallelized with OpenACC can achieve significant speedups over sequential implementations and in some cases, even outperform CUDA implementations. Furthermore, there is less of a programming effort compared to low-level models, such as CUDA and OpenCL, because a majority of the work is left to the compiler and overall, the code needs less restructuring.

At the University of Belgrade, School of Electrical Engineering, Programming 1 and Programming 2 are mandatory courses for all first-year students, with approximately 900 students enrolled each year. To streamline the exam preparation and evaluation for the theoretical aspects of these courses, a test with multiple-choice questions is administered. At the Electrical Engineering and Computing study program, where over 700 students take the course every year, these exams are taken through a paper test. This paper examines the limitations of the existing test assembly tool and proposes improvements through the implementation of a new, more flexible tool in Python.

The number of published scientific paper grows rapidly each year, totaling more than 2.9 million annually. New methodologies and systems have been developed to analyze scientific production and performance indicators from large quantities of data available from the scientific databases, such as Web of Science or Scopus. In this paper, we analyzed the international scientific production and co-authorship patterns for the most productive authors from Serbia based on the obtained Web of Science dataset in the period 2006–2013. We performed bibliometric and scientometric analyses together with statistical and collaboration network analysis, to reveal the causes of extraordinary publishing performance of some authors. For such authors, we found significant inequality in distribution of papers over journals and countries of co-authors, using Gini coefficient and Lorenz curves. Most of the papers belong to multidisciplinary, interdisciplinary, and the field of applied sciences. We have discovered three specific collaboration patterns that lead to high productivity in international collaboration. First pattern corresponds to mega-authorship papers with hundreds of co-authors gathered in specific research groups. The other two collaboration patterns were found in mathematics and multidisciplinary science, mainly application of graph theory and computational methods in physical chemistry. The former pattern results in a star-shaped collaboration network with mostly individual collaborators. The latter pattern includes multiple actors with high betweenness centrality measure and identified brokerage roles. The results are compared with the later period 2014–2023, where high scientific production has been observed in some other fields, such as biology and food science and technology.

Processing of large quantitities of data from bioinformatics domain pose significant challenge for contemporary computing systems. For that reason, it is important to employ all hardware resources available by means of parallelization. In this paper, we compare several Python-based parallelization frameworks and libraries and evaluate them using a simple processing algorithm on spatial transcriptomics data. The results show speedups of up to 60x with significant variation in the execution time depending on the framework used. The results and experiences are discussed in the paper.

Summary Massive‐enrollment computing courses often involve some practical training through programming assignments and projects that are frequent targets for plagiarism. Source code similarity detection tools are used to prevent such misbehavior. Parallel processing has recently become a viable technique for speeding up the processing of large workloads. This article examines the parallelization of a source code similarity detection method based on the greedy string tiling and Karp–Rabin algorithms. Both CPU and GPU parallelization approaches are discussed. The CPU implementation uses Pthreads, whereas the GPU implementation employs CUDA. Depending on the evaluated dataset which consists of real student assignment codes, speedups of up to seven times over the sequential version of the code are achieved. Evaluation results on both platforms are compared and discussed in detail.

Public key cryptography plays an important role in secure communications over insecure channels. Elliptic curve cryptography, as a variant of public key cryptography, has been extensively used in the last decades for such purposes. In this paper, we present a software tool for parallel generation of cryptographic keys based on elliptic curves. Binary method for point multiplication and C++ threads were used in parallel implementation, while secp256k1 elliptic curve was used for testing. Obtained results show speedup of 30% over the sequential solution for 8 threads. The results are briefly discussed in the paper.

Real-time detection of moving objects in a resource-constrained environment, such as a personal mobile device, is a challenging task. Nowadays, cameras of cell phones and other mobile devices produce high-resolution videos. In addition, possible camera motion which is inherent to mobile devices adds further complexity to the image processing. Real-time analysis of those videos can be performed using optimized versions of the background subtraction methods. The focus of this work is an efficient implementation of background subtraction using dual-mode single Gaussian model with age on Android platform. Several optimizations were applied: parallelization through RenderScript framework, block processing and grayscale transformation of pixels, and memory transfer and footprint reduction. Implemented algorithm was evaluated using multiple test scenarios on two different platforms. We observed speedups up to 6 times over the reference sequential implementation, real time performance of 50 FPS for 640 × 480 videos and 20.7 FPS for 1280 × 720 videos. Comparative analysis with state-of-the-art methods on CDNet 2014 PTZ category showed good F1-measure. The obtained results are carefully discussed.

In this paper, the problem of balancing machine learning datasets and its potential solution using generative adversarial networks is presented. Several training methods and models in generating minority class samples were examined using two well-known datasets: MNIST and CIFAR10. In order to achieve data imbalance, a percentage of samples was artificially removed from one class in both datasets. Generative adversarial network is initialized with the parameters of the autoencoder trained over the same dataset. Generated noise is limited based on the distribution of the latent space of the autoencoder. Three methods of generative adversarial network training which provide class label context to the network were examined. Two methods gave satisfactory results for the problem of generating samples from the MNIST dataset, while the method of duplicating labels proved unsatisfactory.