• Journal of Korea Game Society
• /
• v.11 no.2
• /
• pp.131-140
• /
• 2011

Debugging is very important element in programming development. We can find a lot of bug of program we made, and we can fix it. but after a product is released, we need system we can catch bugs as soon as possible. For this, we need to know post-mortem debugging. We will look at post-mortem debugging, and we will talk about process dump. Also when process get the problem, we should get the process dump, but we can have situation process dump was not generated. We will consider this case, and we will examine programming technique which this case can be retrieved. Finally, I will introduce EHModule(exception handler module)

• Journal of the Korea Society of Computer and Information
• /
• v.19 no.4
• /
• pp.17-24
• /
• 2014

Detecting data races is important for debugging shared-memory programs with nested parallelism, because races result in unintended non-deterministic executions of the program. It is especially important to detect the first occurred data races for effective debugging, because the removal of such races may make other affected races disappear or appear. Previous dynamic detection tools for first race detecting can not guarantee that detected races are unaffected races. Also, the tools does not consider the nesting levels or need support of other techniques. This paper suggests a post-mortem tool which collects candidate accesses during program execution and then detects the first races to occur on the program after execution. This technique is efficient, because it guarantees that first races reported by analyzing a nesting level are the races that occur first at the level, and does not require more analyses to the higher nesting levels than the current level.

• Journal of KIISE:Computer Systems and Theory
• /
• v.31 no.1_2
• /
• pp.41-50
• /
• 2004

Detecting races is important for debugging shared-memory Parallel programs, because races result in unintended nondeterministic executions of the programs. Particularly, the first races to occur in an execution of a program must be detected because they can potentially affect other races that occur later. Previous on-the-fly techniques that detect such first races based on candidate events that are likely to participate in the first races monitor access events in order to collect the candidate events during a program execution, and try to report the races only from determining the concurrency relationships of the candidates. Such races reported in this way. however, are not guaranteed to be first races, because they are not determined by taking into account how they are affected with each other. This paper presents a new post-mortem technique that analyzes, on each nesting level, candidate events collected from an execution of a shared-memory program with nested parallelism in order to report only first races. This technique is efficient, because it guarantees that first races reported by analyzing a nesting level are the races that occur first at the level, and does not require more analyses to the higher nesting levels than the current level. The Proposed technique facilitates more practical and effective debugging than the previous techniques, because it guarantees to detect first races if candidate events are collected from an execution instance of the program with nested parallelism.