• Journal of the Institute of Electronics Engineers of Korea CI
• /
• v.38 no.4
• /
• pp.59-71
• /
• 2001

The Current CORBA shows some limitations for its successful deployment in real time system applications. Recently, OMG adopted Real-Time CORBA specification, which is defined as an extension to CORBA. The goal of the Real-Time CORBA is to provide a standard for CORBA ORB implementations that support 'end to end predictability'. In order to support 'end-to-end predictability', Real Time CORBA specifies many components such as priority model, communication protocol configuration, thread management, and etc. Among them, 'priority model' is the most important mechanism for avoiding or bounding priority inversion in CORBA invocations. In this paper, we present our efforts on a design ,and implementation of the Priority Model in Real-Time CORBA specification. The implementation is done as an extension of omniORB2(v.3.0.0), a popular open source non real time ORB. Experiment results demonstrate that our priority model implementation shows better performance and predictability than the non real-time ORB.

• Journal of the Korea Society of Computer and Information
• /
• v.26 no.9
• /
• pp.1-12
• /
• 2021

In this paper, we propose a tool called ARCAV (Atomatic Recovery of CUDA Atomicity violation) to automatically repair atomicity violations in GPU (Graphics Processing Unit) program. ARCAV monitors information of every barrier and memory to make actual memory writes occur at the end of the barrier region or to make the program execute barrier region again. Existing methods do not repair atomicity violations but only detect the atomicity violations in GPU programs because GPU programs generally do not support lock and sleep instructions which are necessary for repairing the atomicity violations. Proposed ARCAV is designed for GPU execution model. ARCAV detects and repairs four patterns of atomicity violations which represent real-world cases. Moreover, ARCAV is independent of memory hierarchy and thread configuration. Our experiments show that the performance of ARCAV is stable regardless of the number of threads or blocks. The overhead of ARCAV is evaluated using four real-world kernels, and its slowdown is 2.1x, in average, of native execution time.