36 research outputs found
State-of-the-art on evolution and reactivity
This report starts by, in Chapter 1, outlining aspects of querying and updating resources on
the Web and on the Semantic Web, including the development of query and update languages
to be carried out within the Rewerse project.
From this outline, it becomes clear that several existing research areas and topics are of
interest for this work in Rewerse. In the remainder of this report we further present state of
the art surveys in a selection of such areas and topics. More precisely: in Chapter 2 we give
an overview of logics for reasoning about state change and updates; Chapter 3 is devoted to briefly describing existing update languages for the Web, and also for updating logic programs;
in Chapter 4 event-condition-action rules, both in the context of active database systems and
in the context of semistructured data, are surveyed; in Chapter 5 we give an overview of some relevant rule-based agents frameworks
On Properties of Update Sequences Based on Causal Rejection
We consider an approach to update nonmonotonic knowledge bases represented as
extended logic programs under answer set semantics. New information is
incorporated into the current knowledge base subject to a causal rejection
principle enforcing that, in case of conflicts, more recent rules are preferred
and older rules are overridden. Such a rejection principle is also exploited in
other approaches to update logic programs, e.g., in dynamic logic programming
by Alferes et al. We give a thorough analysis of properties of our approach, to
get a better understanding of the causal rejection principle. We review
postulates for update and revision operators from the area of theory change and
nonmonotonic reasoning, and some new properties are considered as well. We then
consider refinements of our semantics which incorporate a notion of minimality
of change. As well, we investigate the relationship to other approaches,
showing that our approach is semantically equivalent to inheritance programs by
Buccafurri et al. and that it coincides with certain classes of dynamic logic
programs, for which we provide characterizations in terms of graph conditions.
Therefore, most of our results about properties of causal rejection principle
apply to these approaches as well. Finally, we deal with computational
complexity of our approach, and outline how the update semantics and its
refinements can be implemented on top of existing logic programming engines.Comment: 59 pages, 2 figures, 3 tables, to be published in "Theory and
Practice of Logic Programming
State-of-the-art on evolution and reactivity
This report starts by, in Chapter 1, outlining aspects of querying and updating resources on
the Web and on the Semantic Web, including the development of query and update languages
to be carried out within the Rewerse project.
From this outline, it becomes clear that several existing research areas and topics are of
interest for this work in Rewerse. In the remainder of this report we further present state of
the art surveys in a selection of such areas and topics. More precisely: in Chapter 2 we give
an overview of logics for reasoning about state change and updates; Chapter 3 is devoted to briefly describing existing update languages for the Web, and also for updating logic programs;
in Chapter 4 event-condition-action rules, both in the context of active database systems and
in the context of semistructured data, are surveyed; in Chapter 5 we give an overview of some relevant rule-based agents frameworks
Coherent Integration of Databases by Abductive Logic Programming
We introduce an abductive method for a coherent integration of independent
data-sources. The idea is to compute a list of data-facts that should be
inserted to the amalgamated database or retracted from it in order to restore
its consistency. This method is implemented by an abductive solver, called
Asystem, that applies SLDNFA-resolution on a meta-theory that relates
different, possibly contradicting, input databases. We also give a pure
model-theoretic analysis of the possible ways to `recover' consistent data from
an inconsistent database in terms of those models of the database that exhibit
as minimal inconsistent information as reasonably possible. This allows us to
characterize the `recovered databases' in terms of the `preferred' (i.e., most
consistent) models of the theory. The outcome is an abductive-based application
that is sound and complete with respect to a corresponding model-based,
preferential semantics, and -- to the best of our knowledge -- is more
expressive (thus more general) than any other implementation of coherent
integration of databases
GPU ์๋ฌ ์์ ์ฑ ๋ณด์ฅ์ ์ํ ์ปดํ์ผ๋ฌ ๊ธฐ๋ฒ
ํ์๋
ผ๋ฌธ (๋ฐ์ฌ) -- ์์ธ๋ํ๊ต ๋ํ์ : ๊ณต๊ณผ๋ํ ์ ๊ธฐยท์ปดํจํฐ๊ณตํ๋ถ, 2020. 8. ์ด์ฌ์ง.Due to semiconductor technology scaling and near-threshold voltage computing, soft error resilience has become more important. Nowadays, GPUs are widely used in high performance computing (HPC) because of its efficient parallel processing and modern GPUs designed for HPC use error correction code (ECC) to protect their storage including register files. However, adopting ECC in the register file imposes high area and energy overhead.
To replace the expensive hardware cost of ECC, we propose Penny, a lightweight compiler-directed resilience scheme for GPU register file protection. We combine recent advances in idempotent recovery with low-cost error detection code. Our approach focuses on solving two important problems:
1. Can we guarantee correct error recovery using idempotent execution with error detection code? We show that when an error detection code is used with idempotence recovery, certain restrictions required by previous idempotent recovery schemes are no longer needed. We also propose a software-based scheme to prevent the checkpoint value from being overwritten before the end of the region where the value is required for correct recovery.
2. How do we reduce the execution overhead caused by checkpointing? In GPUs additional checkpointing store instructions inflicts considerably higher overhead compared to CPUs, due to its architectural characteristics, such as lack of store buffers. We propose a number of compiler optimizations techniques that significantly reduce the overhead.๋ฐ๋์ฒด ๋ฏธ์ธ๊ณต์ ๊ธฐ์ ์ด ๋ฐ์ ํ๊ณ ๋ฌธํฑ์ ์ ๊ทผ์ฒ ์ปดํจํ
(near-threashold voltage computing)์ด ๋์
๋จ์ ๋ฐ๋ผ์ ์ํํธ ์๋ฌ๋ก๋ถํฐ์ ๋ณต์์ด ์ค์ํ ๊ณผ์ ๊ฐ ๋์๋ค. ๊ฐ๋ ฅํ ๋ณ๋ ฌ ๊ณ์ฐ ์ฑ๋ฅ์ ์ง๋ GPU๋ ๊ณ ์ฑ๋ฅ ์ปดํจํ
์์ ์ค์ํ ์์น๋ฅผ ์ฐจ์งํ๊ฒ ๋์๊ณ , ์ํผ ์ปดํจํฐ์์ ์ฐ์ด๋ GPU๋ค์ ์๋ฌ ๋ณต์ ์ฝ๋์ธ ECC๋ฅผ ์ฌ์ฉํ์ฌ ๋ ์ง์คํฐ ํ์ผ ๋ฐ ๋ฉ๋ชจ๋ฆฌ ๋ฑ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๋ณดํธํ๊ฒ ๋์๋ค. ํ์ง๋ง ๋ ์ง์คํฐ ํ์ผ์ ECC๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ํฐ ํ๋์จ์ด๋ ์๋์ง ๋น์ฉ์ ํ์๋ก ํ๋ค.
์ด๋ฐ ๊ฐ๋น์ผ ECC์ ํ๋์จ์ด ๋น์ฉ์ ์ค์ด๊ธฐ ์ํด ๋ณธ ๋
ผ๋ฌธ์์๋ ์ปดํ์ผ๋ฌ ๊ธฐ๋ฐ์ ์ ๋น์ฉ GPU ๋ ์ง์คํฐ ํ์ผ ๋ณต์ ๊ธฐ๋ฒ์ธ Penny๋ฅผ ์ ์ํ๋ค. ์ด๋ ์ต์ ์ ๋ฉฑ๋ฑ์ฑ(idempotency) ๊ธฐ๋ฐ ์๋ฌ ๋ณต์ ๊ธฐ๋ฒ์ ์ ๋น์ฉ์ ์๋ฌ ๊ฒ์ถ ์ฝ๋(EDC)์ ๊ฒฐํฉํ ๊ฒ์ด๋ค. ๋ณธ ๋
ผ๋ฌธ์ ๋ค์ ๋๊ฐ์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ์ ์ง์คํ๋ค.
1. ์๋ฌ ๊ฒ์ถ ์ฝ๋ ๊ธฐ๋ฐ์ผ๋ก ๋ฉฑ๋ฑ์ฑ ๊ธฐ๋ฐ ์๋ฌ ๋ณต์์ ์ฌ์ฉ์ ์ํํธ ์๋ฌ๋ก๋ถํฐ์ ์์ ํ ๋ณต์์ ๋ณด์ฅํ ์ ์๋๊ฐ?} ๋ณธ ๋
ผ๋ฌธ์์๋ ์๋ฌ ๊ฒ์ถ ์ฝ๋๊ฐ ๋ฉฑ๋ฑ์ฑ ๊ธฐ๋ฐ ๋ณต์ ๊ธฐ์ ๊ณผ ๊ฐ์ด ์ฌ์ฉ๋์์ ๊ฒฝ์ฐ ๊ธฐ์กด์ ๋ณต์ ๊ธฐ๋ฒ์์ ํ์๋ก ํ๋ ์กฐ๊ฑด๋ค ์์ด๋ ์์ ํ๊ฒ ์๋ฌ๋ก๋ถํฐ ๋ณต์ํ ์ ์์์ ๋ณด์ธ๋ค.
2. ์ฒดํฌํฌ์ธํ
์๋๋ ๋น์ฉ์ ์ด๋ป๊ฒ ์ ๊ฐํ ์ ์๋๊ฐ?} GPU๋ ์คํ ์ด ๋ฒํผ๊ฐ ์๋ ๋ฑ ์ํคํ
์ณ์ ์ธ ํน์ฑ์ผ๋ก ์ธํด์ CPU์ ๋น๊ตํ์ฌ ์ฒดํฌํฌ์ธํธ ๊ฐ์ ์ ์ฅํ๋ ๋ฐ์ ํฐ ์ค๋ฒํค๋๊ฐ ๋ ๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ณธ ๋
ผ๋ฌธ์์๋ ๋ค์ํ ์ปดํ์ผ๋ฌ ์ต์ ํ ๊ธฐ๋ฒ์ ํตํ์ฌ ์ค๋ฒํค๋๋ฅผ ์ค์ธ๋ค.1 Introduction 1
1.1 Why is Soft Error Resilience Important in GPUs 1
1.2 How can the ECC Overhead be Reduced 3
1.3 What are the Challenges 4
1.4 How do We Solve the Challenges 5
2 Comparison of Error Detection and Correction Coding Schemes for Register File Protection 7
2.1 Error Correction Codes and Error Detection Codes 8
2.2 Cost of Coding Schemes 9
2.3 Soft Error Frequency of GPUs 11
3 Idempotent Recovery and Challenges 13
3.1 Idempotent Execution 13
3.2 Previous Idempotent Schemes 13
3.2.1 De Kruijf's Idempotent Translation 14
3.2.2 Bolts's Idempotent Recovery 15
3.2.3 Comparison between Idempotent Schemes 15
3.3 Idempotent Recovery Process 17
3.4 Idempotent Recovery Challenges for GPUs 18
3.4.1 Checkpoint Overwriting 20
3.4.2 Performance Overhead 20
4 Correctness of Recovery 22
4.1 Proof of Safe Recovery 23
4.1.1 Prevention of Error Propagation 23
4.1.2 Proof of Correct State Recovery 24
4.1.3 Correctness in Multi-Threaded Execution 28
4.2 Preventing Checkpoint Overwriting 30
4.2.1 Register renaming 31
4.2.2 Storage Alternation by Checkpoint Coloring 33
4.2.3 Automatic Algorithm Selection 38
4.2.4 Future Works 38
5 Performance Optimizations 40
5.1 Compilation Phases of Penny 40
5.1.1 Region Formation 41
5.1.2 Bimodal Checkpoint Placement 41
5.1.3 Storage Alternation 42
5.1.4 Checkpoint Pruning 43
5.1.5 Storage Assignment 44
5.1.6 Code Generation and Low-level Optimizations 45
5.2 Cost Estimation Model 45
5.3 Region Formation 46
5.3.1 De Kruijf's Heuristic Region Formation 46
5.3.2 Region splitting and Region Stitching 47
5.3.3 Checkpoint-Cost Aware Optimal Region Formation 48
5.4 Bimodal Checkpoint Placement 52
5.5 Optimal Checkpoint Pruning 55
5.5.1 Bolt's Naive Pruning Algorithm and Overview of Penny's Optimal Pruning Algorithm 55
5.5.2 Phase 1: Collecting Global-Decision Independent Status 56
5.5.3 Phase2: Ordering and Finalizing Renaming Decisions 60
5.5.4 Effectiveness of Eliminating the Checkpoints 63
5.6 Automatic Checkpoint Storage Assignment 69
5.7 Low-Level Optimizations and Code Generation 70
6 Evaluation 74
6.1 Test Environment 74
6.1.1 GPU Architecture and Simulation Setup 74
6.1.2 Tested Applications 75
6.1.3 Register Assignment 76
6.2 Performance Evaluation 77
6.2.1 Overall Performance Overheads 77
6.2.2 Impact of Penny's Optimizations 78
6.2.3 Assigning Checkpoint Storage and Its Integrity 79
6.2.4 Impact of Optimal Checkpoint Pruning 80
6.2.5 Impact of Alias Analysis 81
6.3 Repurposing the Saved ECC Area 82
6.4 Energy Impact on Execution 83
6.5 Performance Overhead on Volta Architecture 85
6.6 Compilation Time 85
7 RelatedWorks 87
8 Conclusion and Future Works 89
8.1 Limitation and Future Work 90Docto