Recent deep learning compilers commonly adopt auto-tuning approaches that search for the optimal kernel configuration in tensor programming from scratch, requiring tens of hours per operation and neglecting crucial optimization factors for parallel computing on asymmetric multicore processors. Meanwhile, hand-optimized inference libraries from hardware vendors provide high performance but lack the flexibility and automation needed for emerging models. To close this gap, we propose Luthier , which significantly narrows the search space by selecting the best kernel from existing inference libraries, and also employs cost model-based profiling to quickly determine the most efficient workload distribution for parallel computing. As a result, Luthier achieves up to 2.0x faster execution on convolution-based vision models and transformer-based language models (BERT, GPT) on both CPUs and GPUs, while reducing average tuning time by 95% compared with ArmNN, AutoTVM, Ansor, ONNXRuntime, and TFLite.

Recently, vision transformers (ViTs) have superseded convolutional neural networks in numerous applications, including classification, detection, and segmentation. However, the high computational requirements of ViTs hinder their widespread implementation. To address this issue, researchers have proposed efficient hybrid transformer architectures that combine convolutional and transformer layers with optimized attention computation of linear complexity. Additionally, posttraining quantization (PTQ) has been proposed as a means of mitigating computational demands. For mobile devices, achieving optimal acceleration for ViTs necessitates the strategic integration of quantization techniques and efficient hybrid transformer structures. However, no prior investigation has applied quantization to efficient hybrid transformers. In this article, we discover that applying existing PTQ methods for ViTs to efficient hybrid transformers leads to a drastic accuracy drop, attributed to the four following challenges: 1) highly dynamic ranges; 2) zero-point overflow; 3) diverse normalization; and 4) limited model parameters (https://gitlab.com/ones-ai/q-hyvit.

To adopt convolutional neural networks (CNN) for a range of resource-constrained targets, it is necessary to compress the CNN models by performing quantization, whereby precision representation is converted to a lower bit representation. To overcome problems such as sensitivity of the training dataset, high computational requirements, and large time consumption, post-training quantization methods that do not require retraining have been proposed. In addition, to compensate for the accuracy drop without retraining, previous studies on post-training quantization have proposed several complementary methods: calibration, schemes, clipping, granularity, and mixed-precision. To generate a quantized model with minimal error, it is necessary to study all possible combinations of the methods because each of them is complementary and the CNN models have different characteristics. However, an exhaustive or a heuristic search is either too time-consuming or suboptimal. To overcome this challenge, we propose an auto-tuner known as Quantune, which builds a gradient tree boosting model to accelerate the search for the configurations of quantization and reduce the quantization error. We evaluate and compare Quantune with the random, grid, and genetic algorithms. The experimental results show that Quantune reduces the search time for quantization by approximately 36.5× with an accuracy loss of 0.07–0.65% across six CNN models, including the fragile ones (MobileNet, SqueezeNet, and ShuffleNet). To support multiple targets and adopt continuously evolving quantization works, Quantune is implemented on a full-fledged compiler for deep learning as an open-sourced project.

Summary Mutation testing offers developers a good way to improve the quality of a test set. However, the high cost of executing a large number of mutants remains an issue. This paper examines the possibility of reducing the cost of statement‐level mutant clustering by comparing the number of mutant executions with those of expression‐level and block‐level mutant clustering. The goal is to investigate to what extent the clustering scope should be extended. The experimental results using nine real‐world programs show that statement‐level clustering can reduce the mutant executions that are required by expression‐level clustering by 10.51% on average. Block‐level clustering exhibits an unexpected result; the number of mutant executions with block‐level clustering is only 1.06% times less than that with statement‐level clustering. That is, statement‐level clustering is more cost‐effective than block‐level clustering when considering their clustering overheads. A compound expression plays a major role in providing a cost‐reduction effect in statement‐level clustering. With a compound expression, the number of candidate mutants to be clustered in a statement scope increases, and state change can be comprehensively examined, thereby increasing the possibility of cost reduction. © 2018 John Wiley & Sons, Ltd.

Multithreading is a widely used programming technique that efficiently uses multicore processors. However, correctly executing a multithreaded program is challenging mainly because of intractable concurrency bugs caused by nondeterministic thread scheduling. Data races are one of the main causes of those concurrency bugs, and data race detectors are essential tools to assist long-suffering programmers in locating data races in problematic multithreaded programs. In this paper, we propose a new hybrid detector called SimpleLock+, which accurately detects data races in a scheduling-insensitive manner with a low runtime overhead by combining happens-before and simplified Lockset algorithms. We significantly reduce the runtime slowdowns of previous hybrid detectors by assuming that most data races are caused by accesses to a shared memory location without the protection of locks and that the distance between accesses that cause a data race is not long in an execution trace. In addition, we improve the speed of the detection algorithm by using a simpler data structure and by eliminating redundant operations. The results of the experiments that are conducted on the RoadRunner framework confirm that those assumptions are valid and that the SimpleLock+ detector can efficiently and accurately detect real and potential data races that are caused by inconsistent locking in one execution trace. The results also show that the average runtime slowdown of SimpleLock+ is only 1.09 times that of FastTrack, which is the fastest happens-before race detector, and SimpleLock+ reports the same race warnings with one missing data race as the current accurate hybrid detector.

Data races are one of the major causes of concurrency bugs in multithreaded programs, but they are hard to find due to nondeterministic thread scheduling. Data race detectors are essential tools that help long-suffering programmers to locate data races in multithreaded programs. One type of detectors precisely detects data races but is sensitive to thread scheduling, whereas another type is less sensitive to thread scheduling but reports a considerable number of false positives. In this paper, we propose a new dynamic data race detector called SimpleLock that accurately detects data races in a scheduling insensitive manner with low execution overhead. We reduce execution overhead by using two assumptions. The first is that most data races are caused by the accessing of shared variables without locks. The second is that two accesses that cause a data race have not a long distance between them in an execution trace. The results of experiments conducted on the Road Runner framework confirm that these assumptions are valid and that our SimpleLock detector can efficiently and accurately detect real and potential data races in one execution trace. The results also indicate that the execution overhead of SimpleLock is not much higher than that of FastTrack, the fastest happens-before race detector.

Existing sensor network simulators are not appropriate for indoor sensor network systems. We present RealSSim, the sensor network simulator especially developed for indoor sensor networks. RealSSim considers the structure of buildings and the quality of construction materials for accurate radio propagation analysis. It also supports an attractive visualization of the level as commercial products. In our demonstration, we show the whole process of simulation for two indoor sensor network systems.