A document by Genyuan Yang. Click on the document to view its contents.

Urban transportation systems are essential in fulfilling the requirements of residents while guaranteeing the normal functioning of cities. These systems encompass various modes of transportation, infrastructure, and services that enable people to move within and between urban areas. However, the challenges posed by escalating urbanization, particularly the growing menace of traffic congestion, underscore the pressing need for effective solutions. We propose an Adaptive and Dynamic Spatio-Temporal Network (ADSTN) as an innovative solution to the complexities associated with traffic congestion. The identified shortcomings in existing models, such as their limitations in capturing authentic spatial dependencies, insufficient understanding of the heterogeneous relationship between the temporal and spatial domains, and the oversight of local trend information, motivate the development of ADSTN. The model integrates three key components: a learnable adaptive attention module, a local temporal self-attention block, and a spatio-temporal dynamic graph convolution block. ADSTN stands out for its outstanding performance in handling local spatio-temporal dependencies, periodicity, and dynamics within traffic flow forecasting. Evaluation on three public real-world datasets underscores competitive achievements of ADSTN contrasted to state-of-the-art models, all while maintaining computational efficiency.

The k 2 -tree compact data structure has gained great popularity to represent binary relationships in main memory. It presents a good performance and a good trade-off between storage and execution time. However, datasets being too large, or limited resources, may prevent the dataset from fitting into RAM even in compressed form. This work presents an experimental evaluation of a k 2 -tree in external memory (disk), in terms data access (I/O operation or cache misses) and execution time for 4 types of common queries. We compare the k 2 -tree with other data structures, namely a Quadtree (specifically, a Linear QuadTree, LQT) and the classical adjacency matrix, all of them being in external memory. We used for the test both synthetical as well as large, real world, datasets. Several aspects, such as the size of the memory buffer and its replacement scheme, or specific parameters like the arity ( k value) of the k 2 -tree were considered in the experiments. In terms of storage needs, the k 2 -tree clearly outperforms the other alternatives, in extreme cases needing only 1% of the LQT space, or 0.01% of the adjacency matrix (and for some large datasets neither the LQT nor the adjacency matrix could be built). In terms of performance, except for cases with small datasets, where the adjacency matrix is the best option for some queries, the k 2 -tree is either competitive or outperforms the alternatives.

Deduplicating and sorting large sets of integers is a significant requirement in the field of big data, posing particular challenges in single-threaded or resource-constrained environments. This paper proposes the SlowSort algorithm as an improvement and engineering optimization of the classic BitSort idea, which naturally includes a deduplication function. SlowSort supports negative integers through offset mapping; it significantly compresses space requirements by using the second smallest and second largest values to determine the bit vector range, excluding the influence of outliers; and it significantly improves single-threaded execution efficiency through optimizations such as bitwise operations. Comparative experiments implemented in Java and C++ show that: on high-density integer datasets within the 10 7 range, SlowSort’s average performance surpasses parallel sorting algorithms and is on par with radix sort; on integer sets within the 10 9 range, SlowSort’s performance is similar to parallel sorting and radix sort; on large-scale datasets of one billion elements or more, SlowSort’s performance is 50% lower than parallel sorting and radix sort, but its peak memory overhead is reduced by 50%; across all three scales mentioned above, SlowSort’s performance is more than 8 times faster than standard library sorting algorithms (Java Arrays.sort, C++ std::sort). Therefore, SlowSort provides a solution that balances performance and engineering practicality for large-scale integer deduplication and sorting tasks in specific scenarios.

The popularisation of blockchain-based applications made evident a critical challenge, namely the inherent isolation of these decentralised systems, akin to the disconnected and technologically diverse local area networks of the 1970s. This lack of interoperability limits the potential for widespread adoption and innovation in the blockchain space. While various initiatives aim to bridge this gap, many remain nascent. This paper addresses this issue by proposing a robust architecture and practical implementation to interconnect two Ethereum-based blockchains, enabling seamless smart contract interactions across these chains, and facilitating the exchange of complex information beyond mere token transfers. Our work explores the emerging landscape of Inter-Blockchain Communication (IBC) protocols, highlighting their current maturity and potential, and providing insights on how to overcome the technical hurdles associated with these protocols, particularly in the context of transmitting complex data and executing cross-chain function calls. Additionally, we tackle the challenges posed by linking private blockchains with public ones, ensuring secure and efficient data exchange. This paper aims to inspire blockchain researchers and practitioners, presenting a foundational framework for enhancing blockchain interoperability, including detailed, practical steps for its implementation. By laying the groundwork for more connected blockchain ecosystems, we intend to support the continued evolution and widespread adoption of blockchain technology.

The AVL and red-black trees are binary search trees that guarantee O ( log n ) insertion, deletion, and search. This guarantee requires rebalancing the trees, potentially for each insertion or deletion. Benchmarks demonstrate that the AVL tree is often faster than three red-black tree variants for insertion and deletion, and as fast or faster for search. An improved AVL tree deletion algorithm reduces the rebalancing operations associated with deletion by 20 percent.

Modern processors have instructions to process 16 bytes or more at once. These instructions are called SIMD, for single instruction, multiple data. Recent advances have leveraged SIMD instructions to accelerate parsing of common Internet formats such as JSON and base64. The two major Web browser engines (WebKit and Blink) have adopted SIMD algorithms for parsing HTML on 64-bit ARM processors. During HTML parsing, they quickly identify specific characters with a strategy called vectorized classification. We review their techniques and compare them with a faster alternative. We measure a 20-fold performance improvement in HTML scanning compared to traditional methods on recent ARM processors. Our findings highlight the potential of SIMD-based algorithms for optimizing Web browser performance.

The Domain Name System (DNS) plays a critical role in the functioning of the Internet. It provides a hierarchical name space for locating resources. Data is typically stored in plain text files, possibly spanning gigabytes. Frequent parsing of these files to refresh the data is computationally expensive: processing a zone file can take minutes. We propose a novel approach called simdzone to enhance DNS parsing throughput. We use data parallelism, specifically the Single Instruction Multiple Data (SIMD) instructions available on commodity processors. We show that we can multiply the parsing speed compared to state-of-the-art parsers found in Knot DNS and the NLnet Labs Name Server Daemon (NSD). The resulting software library replaced the parser in NSD.

not-yet-known not-yet-known not-yet-known unknown Mining logic rules from structured knowledge bases is the basis of knowledge engineering. Due to the NP-hardness of the rule mining problem, logic rules cannot be efficiently induced from knowledge bases, especially large-scale ones, and most mining techniques employ algorithmic and architectural optimizations to improve efficiency. Data-oriented optimizations have also been explored to some extent, but the data efficiency is relatively low, and the memory consumption is thus becoming a new challenge for state-of-the-art systems. In this article, we propose a compact and efficient index structure for the maintenance of the intermediate data during top-down rule mining. The index is based on a mapping from constant symbols to integers and the sorting of the mapped integers. We evaluate our method on six datasets which contain up to 160K records and are frequently used as benchmarks in knowledge engineering related tasks. The experimental results show that the proposed technique speeds up the rule mining procedure by 5x on average and reduces memory consumption by up to 70%. The space overhead of the data structure is about twice that of the indexed records, which is more than 80% lower than that of the state-of-the-art technique.

As cyber threats proliferate with increasing sophistication, the timely and accurate generation of security documents adherent to Common Criteria (CC) standards becomes imperative. This study continues the trajectory set by previous research on CCGenTool, which simplifies the creation of Security Target documents, and elevates it through the integration of Llama2, a cutting-edge Large Language Model (LLM), aimed at enhancing justifications for security objectives within CC documentation. Bringing this advancement to fruition, This research employed Parameter-Efficient Fine-Tuning (PEFT) strategies such as Low-Rank Adaptation (LoRA), optimizing Llama2 without compromising its pre-trained complexity. Adopting an extensive dataset of 692 items derived from various Protection Profiles efficiently annotated for relevance and contextuality—the split designated 70% to train the model while reserving 30% for evaluation purposes. By facilitating a sophisticated fine-tuning protocol that allowed tailor AI outputs closely aligned with industry-specific requirements. Benchmark results exhibit commendable performance: in tests contrasting this research fine-tuned LLM against GPT-3.5 utilizing GPT-4 as an analytical frame, it shows that the result is more towards Llama2 in 25 instances against only seven for GPT-3.5; both models’ outcomes converged in quality 18 times. These findings accentuate how AI can assist not only in safeguarding against emerging cyber threats but also caters to the dynamic landscape where up-to-date CC documentation is crucial for effective defense strategies. By intelligently abbreviating complex document production processes entailed in cybersecurity measures, this innovation confers upon developers a significant advantage—reducing barriers and expediting compliance timelines amidst evolving digital risks.

not-yet-known not-yet-known not-yet-known unknown In recent years, Large Models (LMs) have been rapidly developed, including large language models, visual foundation models, and multimodal LMs. They are updated and iterated at a very fast pace. These LMs can accomplish many tasks, e.g., daily work assistant, intelligent customer service, and intelligent factory scheduling. Their development has contributed to various industries in human society. However, the architectural flaws of LMs lead to several problems, including illusions and difficulty in locating errors, limiting their performance. Solving these problems properly can facilitate their further development. This work first introduces the development of LMs and identifies their current problems, including data and energy consumption, catastrophic forgetting, reasoning ability, and localization fault. Then, potential solutions to these problems are provided. Finally, LMs’ applications in autonomous driving technologies and smart industrial productions are discussed. By embracing the advantages of LMs, many industries are expected to achieve promising prospects in the future.

Pseudorandom values are often generated as 64-bit binary words. These random words need to be converted into ranged values without statistical bias. We present an efficient algorithm to generate multiple independent uniformly-random bounded integers from a single uniformly-random binary word, without any bias. In the common case, our method uses one multiplication and no division operations per value produced. In practice, our algorithm can triple the speed of unbiased random shuffling for small to moderately large arrays.

This article presents a novel approach to obfuscating database connection strings using Keyword Cipher, which is based on the Roman Caesar Cipher and Greek Scytale Cipher. This is an important and open problem because database connection strings typically have long substrings of identical and well-known character substrings. These known substrings in related database connection strings greatly increase the risk of their encryption key’s being broken, in addition to having identical initial substrings in their encrypted versions. Our experience applying these two obfuscation techniques to database connection strings show that the simple and easily implemented string obfuscation functions effectively solve the problem of common initial substrings. It also greatly reduces risk of breaking the connections strings encryption keys by hiding the known substrings and making the number of possible string needed to search for grow geometrically. Lastly, the use of obfuscation functions completely eliminates all the commonality between related database connection strings.

In the data era, big data systems have emerged as pivotal tools, underscoring the importance of performance prediction in enhancing the efficiency of big data clusters. Numerous performance models have been proposed, often grounded in artificial intelligence or simulation methodologies. While the buck of research focuses on refining prediction precision and minimizing overhead, limited attention has been given to the consignation and standardization of these models. To bridge this gap between model developers and end-users, this paper introduces AMORA—a novel versatile framework tailored for predicting the performance of big data systems. Leveraging the identified Behavior Descriptions-Computation Submodels (BD-CS) pattern that is prevalent among various big data job performance models, AMORA allows access to different plugins accommodating different performance models’ implementations. This framework also integrates a novel mutable computation graph technique to facilitate backtracking computation. Furthermore, AMORA’s functionality extends to comprehensive end-to-end usability by enabling the acceptance of origin configuration files from diverse big data systems and presenting easily interpretable prediction reports. This work demonstrates AMORA’s efficacy in producing an accurate trace of Hadoop job through the selection of appropriate performance model plugins and parameter adjustments and showcasing the application of the proposed mutable computation graph technique in calculating the starting moment of an early-start reducer. Additionally, two validation experiments are conducted, involving the implementation of various Hadoop and Spark performance models, respectively, to exhibit AMORA’s role as a benchmark platform for implementing various types of big data job performance models catered to diverse big data systems.

A document by Jorma Tarhio. Click on the document to view its contents.

The response time of a website has an impact on the overall user experience. Slow-loading or unresponsive applications can quickly frustrate and alienate users, leading to dissatisfaction and potentially driving them away. Conversely, fast and efficient applications can greatly enhance user engagement, satisfaction, and ultimately contribute to the success of an online business. The main objective of this work is to check and compare the performance between Node.js and Java Spring Boot, in the context of implementing RESTful applications. REST (Representational State Transfer) has emerged as a dominant architectural style for building web services due to its simplicity, scalability, and compatibility with the stateless nature of the web. To achieve this objective, both implementations were created with an identical business use case, aiming to provide the fundamental CRUD operations (Create, Read, Update, and Delete). To conduct the performance analysis, Apache JMeter tool is used that enables the creation of a diverse set of concurrent virtual users, simulating real-world scenarios to load both applications at regular intervals. By subjecting the applications to varying user loads, it can be assessed how each platform performs under different workloads and identify potential bottlenecks and areas for improvement. The results obtained suggest that Node.js excels in faster response times for HTTP GET, ideal for read operations. However, Spring Boot outperforms Node.js for complex operations like POST, PUT, and DELETE under higher user loads. Both faced challenges at 64000 virtual users, with error rates from 10% to 75%, but Spring showed better error handling. Spring required fewer lines of code, benefiting from its environment and dependencies. Resource utilization in Node.js proved to be efficient with CPU load below 40% even under heavy loads. Spring on the other hand provided better response times, exhibited higher CPU usage at times, suggesting more resource-intensive optimization. The comparison emphasizes the importance of technology stack choice in development, speed and performance. The findings serve as a basis for developers to make informed decisions when selecting the appropriate technology stack based on specific project requirements, workload considerations, and performance expectations.

Early advances in the field of quantum computing have provided new opportunities to tackle intricate problems in diverse areas as cryptography, optimization, and simulation. However, current methodologies employed in quantum computing often require, among other things, a broad understanding of quantum hardware and low-level programming languages, posing challenges to software developers in effectively creating and implementing quantum services. This paper advocates the adoption of Software Engineering principles in the field of quantum computing, thereby establishing a higher level of hardware abstraction that allows developers to focus on application development. With this proposal, developers will be able to design and deploy quantum services with less effort, similar to the facilitation provided by Service-Oriented Computing in the development of conventional software services. The present study introduces a Continuous Deployment strategy adapted to the development of quantum services, which covers the creation and deployment of such services. For this purpose, an extension of the OpenAPI Specification is proposed that allows the generation of services implementing quantum algorithms. The proposal was validated through the creation of an API with diverse quantum algorithm implementations, and evaluated through a survey of various developers and students who were introduced to the tool, with positive results.

URLs are fundamental elements of web applications. By applying vector algorithms, we built a fast standard-compliant C++ implementation. Our parser uses three times fewer instructions than competing parsers following WHATWG URL standard (e.g., Servo’s rust-url) and up to eight times fewer instructions than the popular curl parser. The Node.js environment adopted our C++ library. In our tests on realistic data, a recent Node.js version (20.0) with our parser is four to five times faster than the last version with the legacy URL parser.