• Journal of KIISE:Computing Practices and Letters
• /
• v.16 no.7
• /
• pp.775-787
• /
• 2010

Unlike general-purpose CPUs, the GPUs have been specialized as many-core streaming processors, and are frequently replacing the CPUs in an increasing range of computations thanks to their outstanding parallel computing capacity. In order to respond to such trend, NVIDIA has recently issued a new parallel computing architecture called CUDA(Compute Unified Device Architecture), offering a flexible GPU programming environment for GPGPU(General Purpose GPU) computing. In general, when programmers use the CUDA API, they should clearly understand many aspects of GPU's computing architecture to produce efficient parallel software. In this article, we explain several optimization techniques for CUDA programming that we have verified through a lot of experiment and trial and error, and review how those techniques affect the performance of code execution. In particular, we use a specific problem as an example to analyze several elements that affect performances, such as effective accesses to hierarchical memory system, processor occupancy, and latency hiding. In conclusion, we present several directions that may be utilized effectively in CUDA-based parallel programming.

• Journal of Software Assessment and Valuation
• /
• v.17 no.1
• /
• pp.67-73
• /
• 2021

In this paper, a system configuration method that can practice Linux-based programming language online is presented. The proposed system utilizes the web-server function, which is the biggest feature of the Linux operating system, and simulates the telnet and FTP functions without firewalls or other security restrictions, so that it is possible to practice similar to the actual Linux console. To do this, we analyzed the functional elements that a programming tool should have on the web and established an algorithm to implement it. In particular, a method was implemented in which an error message caused by a user's mistake can appear in the same form as the actual telnet screen. As a result of using the implemented learning system in the class for students, it is possible to practice the Linux programming language online, as well as the instructor can directly check and guide all the learners, so the learner's satisfaction is similar to that of the offline class was confirmed.

• Journal of Information Processing Systems
• /
• v.15 no.6
• /
• pp.1438-1448
• /
• 2019

We present a new technique, called VED (very effective debugging), for detecting and correcting division by zero errors for all types of .NET application. We use applications written in C# because C# applications are distributed through the internet and its executable format is used extensively. A tool called Immunity Debugger is used to reverse engineer executable code to get binaries of source code. With this technique, we demonstrate integer division by zero errors, the location of the error causing assembly language code, as well as error recovery done according to user preference. This technique can be extended to work for other programming languages in addition to C#. VED can work on different platforms such as Linux. This technique is simple to implement and economical because all the software used here are open source. Our aims are to simplify the maintenance process and to reduce the cost of the software development life cycle.

• Communications for Statistical Applications and Methods
• /
• v.29 no.6
• /
• pp.641-653
• /
• 2022

Penalized least squares methods are important tools to simultaneously select variables and estimate parameters in linear regression. The penalized maximum likelihood can also be used for the same purpose assuming that the error distribution falls in a certain parametric family of distributions. However, the use of a certain parametric family can suffer a misspecification problem which undermines the estimation accuracy. To give sufficient flexibility to the error distribution, we propose to use the symmetric log-concave error distribution with LASSO penalty. A feasible algorithm to estimate both nonparametric and parametric components in the proposed model is provided. Some numerical studies are also presented showing that the proposed method produces more efficient estimators than some existing methods with similar variable selection performance.

• Transactions of the Korean Society of Mechanical Engineers
• /
• v.15 no.1
• /
• pp.69-77
• /
• 1991

A collision-free trajectory planning algorithm using an iterative learning concept is proposed for dual robot arms in a 3-D common workspace to accurately follow their specified paths with constant velocities. Specifically, a collision-free trajectory minimizing the trajectory error is obtained first by employing the linear programming technique. Then the total operating time is iteratively adjusted based on the maximum trajectory error of the previous iteration so that the collision-free trajectory has no deviation from the specified path and also that the operating time is near-minimal. To show the validity of the proposed algorithm, a numerical example is presented based on two planar robots.

• Journal of the Korea Institute of Information Security & Cryptology
• /
• v.26 no.1
• /
• pp.153-168
• /
• 2016

This paper introduces a structure, features and programming techniques for the CNG(Cryptography API: Next Generation), which is the substitution of the CAPI(Cryptography API) from Microsoft. The CNG allows to optimize a scope of functions and features because it is comprised of independent modules based on plug-in structure. Therefore, the CNG is competitive on development costs and agility to extend. In addition, the CNG supports various functions for the newest cryptographic algorithm, audit, kernel-mode programming with agility and possible to contribute for core cryptography services in a new environment. Therefore, based on these advantageous functions, we analyze the structure of CNG to extend it for the enterprise and the public office. In addition, we implement an error-detection tool for program which utilizes CNG library.

• 제어로봇시스템학회:학술대회논문집
• /
• 2003.10a
• /
• pp.428-432
• /
• 2003

Quantitative Feedback Theory (QFT) is one of most effective methods of robust controller design and can be considered as a suitable method for systems with parametric uncertainties. Particularly it allows us to obtain controllers less conservative than other methods like $H_{\infty}$ and ${\mu}$-synthesis. In QFT method, we transform all the uncertainties and desired specifications to some boundaries in Nichols chart and then we have to find the nominal loop transfer function such that satisfies the boundaries and has the minimum high frequency gain. The major drawback of the QFT method is that there is no effective and useful method for finding this nominal loop transfer function. The usual approach to this problem involves loop-shaping in the Nichols chart by manipulating the poles and zeros of the nominal loop transfer function. This process now aided by recently developed computer aided design tools proceeds by trial and error and its success often depends heavily on the experience of the loop-shaper. Thus for the novice and First time QFT user, there is a genuine need for an automatic loop-shaping tool to generate a first-cut solution. In this paper, we approach the automatic QFT loop-shaping problem by using an algorithm involving Linear Programming (LP) techniques and Genetic Algorithm (GA).

• Journal of Internet Computing and Services
• /
• v.8 no.4
• /
• pp.129-136
• /
• 2007

The domain model pattern which belongs to enterprise architecture patterns has reusability, scalability and maintainability. To use the domain model pattern, mapping with persistency layer, transaction management and various services are needed. This paper proposes that relationship management service to solve a consistency error which arises in case of removing domain objects. The proposed relationship management service monitors methods of domain objects and intercepts the flow of control to solve the reference errors. This service is implemented by using AOP(Aspect-Oriented Programming), so it can provide the service without modifications of domain objects and other services.

• Journal of Korea Game Society
• /
• v.21 no.1
• /
• pp.55-66
• /
• 2021

Multi-thread programming is essential in high performance game programming. But, the widely used C++11 shared_ptr and weak_ptr have malfunction and performance problems in multi-thread environments. In this paper, we propose Lock-Free shared_ptr and weak_ptr, which have higher performance than current error preventing methods. These use a non-blocking algorithm to prevent data race in multi-thread environments. As a result of experimenting in an 8 thread environment, performance has improved up to 7424% in a situation where competition between threads is low, and 3767% in high competition.

• Journal of Information Processing Systems
• /
• v.18 no.1
• /
• pp.97-114
• /
• 2022

Interest is increasing in electrocardiogram (ECG) signal analysis for embedded devices, creating the need to develop an algorithm suitable for a low-power, low-memory embedded device. Linear approximation of the ECG signal facilitates the detection of fiducial points by expressing the signal as a small number of vertices. However, dynamic programming, a global optimization method used for linear approximation, has the disadvantage of high complexity using memoization. In this paper, the calculation area and memory usage are improved using a linear approximated template. The proposed algorithm reduces the calculation area required for dynamic programming through local optimization around the vertices of the template. In addition, it minimizes the storage space required by expressing the time information using the error from the vertices of the template, which is more compact than the time difference between vertices. When the length of the signal is L, the number of vertices is N, and the margin tolerance is M, the spatial complexity improves from O(NL) to O(NM). In our experiment, the linear approximation processing time was 12.45 times faster, from 18.18 ms to 1.46 ms on average, for each beat. The quality distribution of the percentage root mean square difference confirms that the proposed algorithm is a stable approximation.