• Journal of the Korea Institute of Information and Communication Engineering
• /
• v.16 no.3
• /
• pp.391-398
• /
• 2012

Detecting races is important for debugging shared-memory parallel programs, because the races result in unintended non-deterministic executions of the programs. Previous on-the-fly techniques to detect races in parallel programs with general inter-thread coordination show serious space overhead which depends on the maximum parallelism of the program. Therefore, this paper presents a loop splitting technique for on-the-fly race detection of parallel programs which is more efficient in space complexity than previous techniques. This loop splitting technique is the debugged program which preserves semantics of the original program. Monitering loop splitting program in on-the-fly can detect first races.

• Journal of KIISE:Computer Systems and Theory
• /
• v.30 no.7_8
• /
• pp.341-351
• /
• 2003

For debugging effectively the shared-memory programs with nested parallelism, it is important to detect efficiently the first races which incur non-deterministic executions of the programs. Previous on-the-fly technique detects the first races in two passes, and shows inefficiencies both in execution time and memory space because the size of an access history for each shared variable depends on the maximum parallelism of program. This paper proposes a new on-the-fly technique to detect the first races in two passes, which is constant in both the number of event comparisons and the space complexity on each access to shared variable because the size of an access history for each shared variable is a small constant. This technique therefore makes on-the-fly race detection more efficient and practical for debugging shared-memory programs with nested parallelism.

• The KIPS Transactions:PartA
• /
• v.8A no.3
• /
• pp.253-260
• /
• 2001

It is important to detect races for debugging shared-memoy parallel programs, because the races cause unintended nondeterministic program execution. Previous on-the-fly techniques to detect races can not guarantee the first race detection in nested parallel programs. Detecting the first race is important for debugging parallel programs, since the removal of the first race may make the next occurred races disappear. In this paper, we presents an on-the-fly detection technique to detect all of the first races through the reexecution of the debugged programs. We assume that the debugged parallel program may have one-way nested parallel programs. The number of reexecution is at the least the nesting depth of the program in the worst case. The space complexity is O(VT) and the time complexity to detect race in each access of access history is O(T), where V is number of shared variables and T is the maximum parallelism of the program. This efficiency of our technique in each execution is the same with the previous on-the-fly detection techniques. Therefore, this technique makes debugging parallel programs more effective and practical.

• Journal of KIISE:Computer Systems and Theory
• /
• v.32 no.11_12
• /
• pp.705-716
• /
• 2005

There exist many feature point detection algorithms that developed in pattern recognition research . However, interactive applications for the pen-input displays such as Tablet PCs and LCD tablets have set different goals; reliable segmentation for different drawing styles and real-time on-the-fly fieature point defection. This paper presents a curvature estimation method crucial for segmenting freeHand pen input. It considers only local shape descriptors, thus, peforming a novel curvature estimation on-the-fly while drawing on a pen-input display This has been used for pen marking recognition to build a 3D sketch-based modeling application.

• Journal of KIISE:Computer Systems and Theory
• /
• v.26 no.9
• /
• pp.1042-1054
• /
• 1999

공유메모리 병렬프로그램의 오류수정에서 경합의 탐지는 중요하다. 왜냐하면 경합은 잘못된 수행 결과를 초래할 뿐만 아니라, 의도하지 않은 프로그램의 비결정적인 수행을 유발하여 오류수정을 어렵게 하기 때문이다. 특히 최초경합의 탐지는 더욱 중요하다. 그 이유는 최초경합을 제거함으로써 나머지 경합들을 방지할 수도 있기 때문이다. 기존의 수행중 경합 탐지기법들은 접근별 보고방식을 기반으로 하는데, 이 기법들은 임의 공유변수에 대한 병행 쓰레드들의 모든 접근사건들을 검사하기 위해서 접근역사라는 유일한 공유정보를 이용하므로 탐지과정에 심각한 병목현상을 유발시킨다. 그러나, 최초경합 탐지를 위한 경우 이러한 병목현상은 크게 개선될 수 있다. 본 논문에서는, 각 접근사건 검사를 위해 각 쓰레드에 공유되지 않는 독립적인 접근역사를 별개로 두고, 경합을 보고하는 시점인 쓰레드 합류시점에서만 공유되는 접근역사를 이용하도록 함으로써 병목현상을 개선하여 최초경합을 탐지할 수 있는 새로운 수행중 탐지기법을 제안한다. 그러므로 본 기법은 최초경합을 보다 효율적으로 탐지할 수 있기 때문에 수행중 경합 탐지를 더욱 효율적이고 실용적으로 할 수 있다. Abstract Detecting races is important for debugging shared-memory parallel programs, because the races lead to unintended nondeterministic executions of the programs as well as erroneous result and then make debugging programs difficult. Especially, detecting the first races is more important. The reason is that the removal of the first races can make other races disappear. Most existing on-the-fly techniques to detect the races are based on per- access reporting method incurring the serious central bottleneck, because the techniques use unique shared information called access history for checking all accesses of concurrent threads to a shared variable. Such bottleneck, however, can be improved considerably in case of detecting first races. This paper presents a new on-the-fly technique which detects the first races with reduced bottleneck through checking each accesses with private access histories and finally reporting races with shared access histories. Therefore, this technique makes on-the-fly race detection more efficient and practical.

• The KIPS Transactions:PartA
• /
• v.9A no.4
• /
• pp.525-534
• /
• 2002

Race conditions, races in short, need to be detected for debugging parallel programs, because the races result in unintended non-deterministic executions. To detect the races in an execution of program, previous techniques use a centralized data structure which may incur serious bottleneck in generating concurrency information, or show inefficient time complexity which depends on the degree of nested parallelism in comparing any two of them. We propose a new labeling scheme in this paper, which is scalable in generating the concurrency information without bottleneck by using private data structure, and improves time complexity into constant in checking concurrency. The scalability and time efficiency therfore makes on-the-fly race detection efficient not only for programs with either shared-memory or message-passing, but also for programs with mixed model of the two.

• Journal of KIISE:Computer Systems and Theory
• /
• v.34 no.7
• /
• pp.267-275
• /
• 2007

Message races should be detected for debugging message-passing parallel programs because they can cause non-deterministic executions. Specially, it is important to detect the first race in each process because the first race can cause the occurrence of the other races in the same process. The previous techniques for detecting the first races require more than two monitored runs of a program or analyze a trace file which size is proportional to the number of messages. In this paper we introduce an on-the-fly technique to detect the first race in each process without generating any trace file. In the experiment we test the accuracy of our technique with some benchmark programs and it shows that our technique detects the first race in each process in all benchmark programs.

• Proceedings of the IEEK Conference
• /
• 2000.07b
• /
• pp.715-718
• /
• 2000

Although shared memory parallel programs are designed to be deterministic both in their final results and intermediate states, the races that occur when different processes access a common memory location in an order not guaranteed by synchronization could result in unintended non-deterministic executions of the program. So, Detecting races, particularly first data races, is important for debugging explicit shared memory parallel programs. It is possible that all data races reported by other on-the-fly algorithms would disappear once the first races were removed. To detect races parallel programs with nested loops and inter-thread coordination, it must guarantee the order of synchronization operations in an execution instance. In this paper, we propose an improved restructuring method that guarantee ordering execution instance and preserve the semantics of original program. This method requires O(np) time and (s + up) space, where n is the number of total operations, s is the number of synchronization operations and p is the number of parallelism in the execution. Also, this method makes on-the-fly detection of parallel program with nested loops and inter-thread coordination more easily in space and time complexity.

• Journal of the Korea Institute of Information Security & Cryptology
• /
• v.32 no.5
• /
• pp.881-890
• /
• 2022

As individual and group users actively use drones, the risks (Intrusion, Information leakage, and Sircraft crashes and so on) in no-fly zones are also increasing. Therefore, it is necessary to build a system that can detect drones intruding into the no-fly zone. General acoustic drone detection researches do not derive location-independent performance by directly learning drone sound including environmental noise in a deep learning model to overcome environmental noise. In this paper, we propose a drone detection system that collects sounds including environmental noise, and detects drones by removing noise from target sound. After removing environmental noise from the collected sound, the proposed system predicts the drone sound using Mel spectrogram and CNN deep learning. As a result, It is confirmed that the drone detection performance, which was weak due to unstudied environmental noises, can be improved by more than 7%.

• Journal of KIISE:Computer Systems and Theory
• /
• v.32 no.2
• /
• pp.49-54
• /
• 2005

This Paper Presents a non-blocking deadlock detection scheme with immediate cycle detection in multiprocessing systems. We assume an expedient state and a special case where each type of resource has one unit and each request is limited to one resource unit at a time. Unlike the previous deadlock detection schemes, this new method takes O(1) time for detecting a cycle and O(n+m) time for blocking or handling resource release where n and m are the number of processes and that of resources in the system. The deadlock detection latency is thus minimized and is constant regardless of n and m. However, in a multiprocessing system, the operating system can handle the blocking or release on-the-fly running on a separate processor, thus not interfering with user process execution. To some applications where deadlock is concerned, a predictable and zero-latency deadlock detection scheme could be very useful.