1,716 research outputs found
The PARSE Programming Paradigm. Part I: Software Development Methodology. Part II: Software Development Support Tools
The programming methodology of PARSE (parallel software environment), a software environment being developed for reconfigurable non-shared memory parallel computers, is described. This environment will consist of an integrated collection of language interfaces, automatic and semi-automatic debugging and analysis tools, and operating system โall of which are made more flexible by the use of a knowledge-based implementation for the tools that make up PARSE. The programming paradigm supports the user freely choosing among three basic approaches /abstractions for programming a parallel machine: logic-based descriptive, sequential-control procedural, and parallel-control procedural programming. All of these result in efficient parallel execution. The current work discusses the methodology underlying PARSE, whereas the companion paper, โThe PARSE Programming Paradigm โ II: Software Development Support Tools,โ details each of the component tools
Agile Development of Linux Schedulers with Ekiben
Kernel task scheduling is important for application performance, adaptability
to new hardware, and complex user requirements. However, developing, testing,
and debugging new scheduling algorithms in Linux, the most widely used cloud
operating system, is slow and difficult. We developed Ekiben, a framework for
high velocity development of Linux kernel schedulers. Ekiben schedulers are
written in safe Rust, and the system supports live upgrade of new scheduling
policies into the kernel, userspace debugging, and bidirectional communication
with applications. A scheduler implemented with Ekiben achieved near identical
performance (within 1% on average) to the default Linux scheduler CFS on a wide
range of benchmarks. Ekiben is also able to support a range of research
schedulers, specifically the Shinjuku scheduler, a locality aware scheduler,
and the Arachne core arbiter, with good performance.Comment: 13 pages, 5 figures, submitted to Eurosys 202
A Multiprocessor Operating System Simulator
This paper describes a multiprocessor operating system simulator that was developed by the authors in the Fall semester of 1987. The simulator was built in response to the need to provide students with an environment in which to build and test operating system concepts as part of the coursework of a third-year undergraduate operating systems course. Written in C++, the simulator uses the co-routine style task package that is distributed with the AT&T C++ Translator to provide a hierarchy of classes that represents a broad range of operating system software and hardware components. The class hierarchy closely follows that of the 'Choices' family of operating systems for loosely- and tightly-coupled multiprocessors. During an operating system course, these classes are refined and specialized by students in homework assignments to facilitate experimentation with different aspects of operating system design and policy decisions. The current implementation runs on the IBM RT PC under 4.3bsd UNIX
๋ณ๋ ฌ ๋ฐ ๋ถ์ฐ ์๋ฒ ๋๋ ์์คํ ์ ์ํ ๋ชจ๋ธ ๊ธฐ๋ฐ ์ฝ๋ ์์ฑ ํ๋ ์์ํฌ
ํ์๋
ผ๋ฌธ(๋ฐ์ฌ)--์์ธ๋ํ๊ต ๋ํ์ :๊ณต๊ณผ๋ํ ์ปดํจํฐ๊ณตํ๋ถ,2020. 2. ํ์ํ.์ํํธ์จ์ด ์ค๊ณ ์์ฐ์ฑ ๋ฐ ์ ์ง๋ณด์์ฑ์ ํฅ์์ํค๊ธฐ ์ํด ๋ค์ํ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์ด ์ ์๋์์ง๋ง, ๋๋ถ๋ถ์ ์ฐ๊ตฌ๋ ์์ฉ ์ํํธ์จ์ด๋ฅผ ํ๋์ ํ๋ก์ธ์์์ ๋์์ํค๋ ๋ฐ์ ์ด์ ์ ๋ง์ถ๊ณ ์๋ค. ๋ํ, ์๋ฒ ๋๋ ์์คํ
์ ๊ฐ๋ฐํ๋ ๋ฐ์ ํ์ํ ์ง์ฐ์ด๋ ์์ ์๊ตฌ ์ฌํญ์ ๋ํ ๋น๊ธฐ๋ฅ์ ์๊ตฌ ์ฌํญ์ ๊ณ ๋ คํ์ง ์๊ณ ์๊ธฐ ๋๋ฌธ์ ์ผ๋ฐ์ ์ธ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์ ์๋ฒ ๋๋ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ๋ ๋ฐ์ ์ ์ฉํ๋ ๊ฒ์ ์ ํฉํ์ง ์๋ค.
์ด ๋
ผ๋ฌธ์์๋ ๋ณ๋ ฌ ๋ฐ ๋ถ์ฐ ์๋ฒ ๋๋ ์์คํ
์ ๋์์ผ๋ก ํ๋ ์ํํธ์จ์ด๋ฅผ ๋ชจ๋ธ๋ก ํํํ๊ณ , ์ด๋ฅผ ์ํํธ์จ์ด ๋ถ์์ด๋ ๊ฐ๋ฐ์ ํ์ฉํ๋ ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์ ์๊ฐํ๋ค. ์ฐ๋ฆฌ์ ๋ชจ๋ธ์์ ์์ฉ ์ํํธ์จ์ด๋ ๊ณ์ธต์ ์ผ๋ก ํํํ ์ ์๋ ์ฌ๋ฌ ๊ฐ์ ํ์คํฌ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ํ๋์จ์ด ํ๋ซํผ๊ณผ ๋
๋ฆฝ์ ์ผ๋ก ๋ช
์ธํ๋ค. ํ์คํฌ ๊ฐ์ ํต์ ๋ฐ ๋๊ธฐํ๋ ๋ชจ๋ธ์ด ์ ์ํ ๊ท์ฝ์ด ์ ํด์ ธ ์๊ณ , ์ด๋ฌํ ๊ท์ฝ์ ํตํด ์ค์ ํ๋ก๊ทธ๋จ์ ์คํํ๊ธฐ ์ ์ ์ํํธ์จ์ด ์๋ฌ๋ฅผ ์ ์ ๋ถ์์ ํตํด ํ์ธํ ์ ์๊ณ , ์ด๋ ์์ฉ์ ๊ฒ์ฆ ๋ณต์ก๋๋ฅผ ์ค์ด๋ ๋ฐ์ ๊ธฐ์ฌํ๋ค. ์ง์ ํ ํ๋์จ์ด ํ๋ซํผ์์ ๋์ํ๋ ํ๋ก๊ทธ๋จ์ ํ์คํฌ๋ค์ ํ๋ก์ธ์์ ๋งคํํ ์ดํ์ ์๋์ ์ผ๋ก ํฉ์ฑํ ์ ์๋ค.
์์ ๋ชจ๋ธ ๊ธฐ๋ฐ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์์ ์ฌ์ฉํ๋ ํ๋ก๊ทธ๋จ ํฉ์ฑ๊ธฐ๋ฅผ ๋ณธ ๋
ผ๋ฌธ์์ ์ ์ํ์๋๋ฐ, ๋ช
์ธํ ํ๋ซํผ ์๊ตฌ ์ฌํญ์ ๋ฐํ์ผ๋ก ๋ณ๋ ฌ ๋ฐ ๋ถ์ฐ ์๋ฒ ๋๋ ์์คํ
์์์ ๋์ํ๋ ์ฝ๋๋ฅผ ์์ฑํ๋ค. ์ฌ๋ฌ ๊ฐ์ ์ ํ์ ๋ชจ๋ธ๋ค์ ๊ณ์ธต์ ์ผ๋ก ํํํ์ฌ ์์ฉ์ ๋์ ํํ๋ฅผ ๋ํ๊ณ , ํฉ์ฑ๊ธฐ๋ ์ฌ๋ฌ ๋ชจ๋ธ๋ก ๊ตฌ์ฑ๋ ๊ณ์ธต์ ์ธ ๋ชจ๋ธ๋ก๋ถํฐ ๋ณ๋ ฌ์ฑ์ ๊ณ ๋ คํ์ฌ ํ์คํฌ๋ฅผ ์คํํ ์ ์๋ค. ๋ํ, ํ๋ก๊ทธ๋จ ํฉ์ฑ๊ธฐ์์ ๋ค์ํ ํ๋ซํผ์ด๋ ๋คํธ์ํฌ๋ฅผ ์ง์ํ ์ ์๋๋ก ์ฝ๋๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ๋ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ๋ณธ ๋
ผ๋ฌธ์์ ์ ์ํ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์ 6๊ฐ์ ํ๋์จ์ด ํ๋ซํผ๊ณผ 3 ์ข
๋ฅ์ ๋คํธ์ํฌ๋ก ๊ตฌ์ฑ๋์ด ์๋ ์ค์ ๊ฐ์ ์ํํธ์จ์ด ์์คํ
์์ฉ ์์ ์ ์ด์ข
๋ฉํฐ ํ๋ก์ธ์๋ฅผ ํ์ฉํ๋ ์๊ฒฉ ๋ฅ ๋ฌ๋ ์์ ๋ฅผ ์ํํ์ฌ ๊ฐ๋ฐ ๋ฐฉ๋ฒ๋ก ์ ์ ์ฉ ๊ฐ๋ฅ์ฑ์ ์ํํ์๋ค. ๋ํ, ํ๋ก๊ทธ๋จ ํฉ์ฑ๊ธฐ๊ฐ ์๋ก์ด ํ๋ซํผ์ด๋ ๋คํธ์ํฌ๋ฅผ ์ง์ํ๊ธฐ ์ํด ํ์๋ก ํ๋ ๊ฐ๋ฐ ๋น์ฉ๋ ์ค์ ์ธก์ ๋ฐ ์์ธกํ์ฌ ์๋์ ์ผ๋ก ์ ์ ๋
ธ๋ ฅ์ผ๋ก ์๋ก์ด ํ๋ซํผ์ ์ง์ํ ์ ์์์ ํ์ธํ์๋ค.
๋ง์ ์๋ฒ ๋๋ ์์คํ
์์ ์์์น ๋ชปํ ํ๋์จ์ด ์๋ฌ์ ๋ํด ๊ฒฐํจ์ ๊ฐ๋ดํ๋ ๊ฒ์ ํ์๋ก ํ๊ธฐ ๋๋ฌธ์ ๊ฒฐํจ ๊ฐ๋ด์ ๋ํ ์ฝ๋๋ฅผ ์๋์ผ๋ก ์์ฑํ๋ ์ฐ๊ตฌ๋ ์งํํ์๋ค. ๋ณธ ๊ธฐ๋ฒ์์ ๊ฒฐํจ ๊ฐ๋ด ์ค์ ์ ๋ฐ๋ผ ํ์คํฌ ๊ทธ๋ํ๋ฅผ ์์ ํ๋ ๋ฐฉ์์ ํ์ฉํ์์ผ๋ฉฐ, ๊ฒฐํจ ๊ฐ๋ด์ ๋น๊ธฐ๋ฅ์ ์๊ตฌ ์ฌํญ์ ์์ฉ ๊ฐ๋ฐ์๊ฐ ์ฝ๊ฒ ์ ์ฉํ ์ ์๋๋ก ํ์๋ค. ๋ํ, ๊ฒฐํจ ๊ฐ๋ด ์ง์ํ๋ ๊ฒ๊ณผ ๊ด๋ จํ์ฌ ์ค์ ์๋์ผ๋ก ๊ตฌํํ์ ๊ฒฝ์ฐ์ ๋น๊ตํ์๊ณ , ๊ฒฐํจ ์ฃผ์
๋๊ตฌ๋ฅผ ์ด์ฉํ์ฌ ๊ฒฐํจ ๋ฐ์ ์๋๋ฆฌ์ค๋ฅผ ์ฌํํ๊ฑฐ๋, ์์๋ก ๊ฒฐํจ์ ์ฃผ์
ํ๋ ์คํ์ ์ํํ์๋ค.
๋ง์ง๋ง์ผ๋ก ๊ฒฐํจ ๊ฐ๋ด๋ฅผ ์คํํ ๋์ ํ์ฉํ ๊ฒฐํจ ์ฃผ์
๋๊ตฌ๋ ๋ณธ ๋
ผ๋ฌธ์ ๋ ๋ค๋ฅธ ๊ธฐ์ฌ ์ฌํญ ์ค ํ๋๋ก ๋ฆฌ๋
์ค ํ๊ฒฝ์ผ๋ก ๋์์ผ๋ก ์์ฉ ์์ญ ๋ฐ ์ปค๋ ์์ญ์ ๊ฒฐํจ์ ์ฃผ์
ํ๋ ๋๊ตฌ๋ฅผ ๊ฐ๋ฐํ์๋ค. ์์คํ
์ ๊ฒฌ๊ณ ์ฑ์ ๊ฒ์ฆํ๊ธฐ ์ํด ๊ฒฐํจ์ ์ฃผ์
ํ์ฌ ๊ฒฐํจ ์๋๋ฆฌ์ค๋ฅผ ์ฌํํ๋ ๊ฒ์ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ์ผ๋ก, ๋ณธ ๋
ผ๋ฌธ์์ ๊ฐ๋ฐ๋ ๊ฒฐํจ ์ฃผ์
๋๊ตฌ๋ ์์คํ
์ด ๋์ํ๋ ๋์ค์ ์ฌํ ๊ฐ๋ฅํ ๊ฒฐํจ์ ์ฃผ์
ํ ์ ์๋ ๋๊ตฌ์ด๋ค. ์ปค๋ ์์ญ์์์ ๊ฒฐํจ ์ฃผ์
์ ์ํด ๋ ์ข
๋ฅ์ ๊ฒฐํจ ์ฃผ์
๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ฉฐ, ํ๋๋ ์ปค๋ GNU ๋๋ฒ๊ฑฐ๋ฅผ ์ด์ฉํ ๋ฐฉ๋ฒ์ด๊ณ , ๋ค๋ฅธ ํ๋๋ ARM ํ๋์จ์ด ๋ธ๋ ์ดํฌํฌ์ธํธ๋ฅผ ํ์ฉํ ๋ฐฉ๋ฒ์ด๋ค. ์์ฉ ์์ญ์์ ๊ฒฐํจ์ ์ฃผ์
ํ๊ธฐ ์ํด GDB ๊ธฐ๋ฐ ๊ฒฐํจ ์ฃผ์
๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ๋์ผ ์์คํ
ํน์ ์๊ฒฉ ์์คํ
์ ์์ฉ์ ๊ฒฐํจ์ ์ฃผ์
ํ ์ ์๋ค. ๊ฒฐํจ ์ฃผ์
๋๊ตฌ์ ๋ํ ์คํ์ ODROID-XU4 ๋ณด๋์์ ์งํํ์๋ค.While various software development methodologies have been proposed to increase the design productivity and maintainability of software, they usually focus on the development of application software running on a single processing element, without concern about the non-functional requirements of an embedded system such as latency and resource requirements.
In this thesis, we present a model-based software development method for parallel and distributed embedded systems. An application is specified as a set of tasks that follow a set of given rules for communication and synchronization in a hierarchical fashion, independently of the hardware platform. Having such rules enables us to perform static analysis to check some software errors at compile time to reduce the verification difficulty. Platform-specific program is synthesized automatically after mapping of tasks onto processing elements is determined.
The program synthesizer is also proposed to generate codes which satisfies platform requirements for parallel and distributed embedded systems. As multiple models which can express dynamic behaviors can be depicted hierarchically, the synthesizer supports to manage multiple task graphs with a different hierarchy to run tasks with parallelism. Also, the synthesizer shows methods of managing codes for heterogeneous platforms and generating various communication methods. The viability of the proposed software development method is verified with a real-life surveillance application that runs on six processing elements with three remote communication methods, and remote deep learning example is conducted to use heterogeneous multiprocessing components on distributed systems. Also, supporting a new platform and network requires a small effort by measuring and estimating development costs.
Since tolerance to unexpected errors is a required feature of many embedded systems, we also support an automatic fault-tolerant code generation. Fault tolerance can be applied by modifying the task graph based on the selected fault tolerance configurations, so the non-functional requirement of fault tolerance can be easily adopted by an application developer. To compare the effort of supporting fault tolerance, manual implementation of fault tolerance is performed. Also, the fault tolerance method is tested with the fault injection tool to emulate fault scenarios and inject faults randomly.
Our fault injection tool, which has used for testing our fault-tolerance method, is another work of this thesis. Emulating fault scenarios by intentionally injecting faults is commonly used to test and verify the robustness of a system. To emulate faults on an embedded system, we present a run-time fault injection framework that can inject a fault on both a kernel and application layer of Linux-based systems. For injecting faults on a kernel layer, two complementary fault injection techniques are used. One is based on Kernel GNU Debugger, and the other is using a hardware breakpoint supported by the ARM architecture. For application-level fault injection, the GDB-based fault injection method is used to inject a fault on a remote application. The viability of the proposed fault injection tool is proved by real-life experiments with an ODROID-XU4 system.Chapter 1 Introduction 1
1.1 Motivation 1
1.2 Contribution 6
1.3 Dissertation Organization 8
Chapter 2 Background 9
2.1 HOPES: Hope of Parallel Embedded Software 9
2.1.1 Software Development Procedure 9
2.1.2 Components of HOPES 12
2.2 Universal Execution Model 13
2.2.1 Task Graph Specification 13
2.2.2 Dataflow specification of an Application 15
2.2.3 Task Code Specification and Generic APIs 21
2.2.4 Meta-data Specification 23
Chapter 3 Program Synthesis for Parallel and Distributed Embedded Systems 24
3.1 Motivational Example 24
3.2 Program Synthesis Overview 26
3.3 Program Synthesis from Hierarchically-mixed Models 30
3.4 Platform Code Synthesis 33
3.5 Communication Code Synthesis 36
3.6 Experiments 40
3.6.1 Development Cost of Supporting New Platforms and Networks 40
3.6.2 Program Synthesis for the Surveillance System Example 44
3.6.3 Remote GPU-accelerated Deep Learning Example 46
3.7 Document Generation 48
3.8 Related Works 49
Chapter 4 Model Transformation for Fault-tolerant Code Synthesis 56
4.1 Fault-tolerant Code Synthesis Techniques 56
4.2 Applying Fault Tolerance Techniques in HOPES 61
4.3 Experiments 62
4.3.1 Development Cost of Applying Fault Tolerance 62
4.3.2 Fault Tolerance Experiments 62
4.4 Random Fault Injection Experiments 65
4.5 Related Works 68
Chapter 5 Fault Injection Framework for Linux-based Embedded Systems 70
5.1 Background 70
5.1.1 Fault Injection Techniques 70
5.1.2 Kernel GNU Debugger 71
5.1.3 ARM Hardware Breakpoint 72
5.2 Fault Injection Framework 74
5.2.1 Overview 74
5.2.2 Architecture 75
5.2.3 Fault Injection Techniques 79
5.2.4 Implementation 83
5.3 Experiments 90
5.3.1 Experiment Setup 90
5.3.2 Performance Comparison of Two Fault Injection Methods 90
5.3.3 Bit-flip Fault Experiments 92
5.3.4 eMMC Controller Fault Experiments 94
Chapter 6 Conclusion 97
Bibliography 99
์ ์ฝ 108Docto
The exploitation of parallelism on shared memory multiprocessors
PhD ThesisWith the arrival of many general purpose shared memory multiple processor
(multiprocessor) computers into the commercial arena during the mid-1980's, a
rift has opened between the raw processing power offered by the emerging
hardware and the relative inability of its operating software to effectively deliver
this power to potential users. This rift stems from the fact that, currently, no
computational model with the capability to elegantly express parallel activity is
mature enough to be universally accepted, and used as the basis for programming
languages to exploit the parallelism that multiprocessors offer. To add to this,
there is a lack of software tools to assist programmers in the processes of designing
and debugging parallel programs.
Although much research has been done in the field of programming languages,
no undisputed candidate for the most appropriate language for programming
shared memory multiprocessors has yet been found. This thesis examines why this
state of affairs has arisen and proposes programming language constructs,
together with a programming methodology and environment, to close the ever
widening hardware to software gap.
The novel programming constructs described in this thesis are intended for use
in imperative languages even though they make use of the synchronisation
inherent in the dataflow model by using the semantics of single assignment when
operating on shared data, so giving rise to the term shared values. As there are
several distinct parallel programming paradigms, matching flavours of shared
value are developed to permit the concise expression of these paradigms.The Science and Engineering Research Council
Partial replay of long-running applications
Bugs in deployed software can be extremely difficult to track down. Invasive logging techniques, such as logging all non-deterministic inputs, can incur substantial runtime overheads. This paper shows how symbolic analysis can be used to re-create path equivalent executions for very long running programs such as databases and web servers. The goal is to help developers debug such long-running programs by allowing them to walk through an execution of the last few requests or transactions leading up to an error. The challenge is to provide this functionality without the high runtime overheads associated with traditional replay techniques based on input logging or memory snapshots. Our approach achieves this by recording a small amount of information about program execution, such as the direction of branches taken, and then using symbolic analysis to reconstruct the execution of the last few inputs processed by the application, as well as the state of memory before these inputs were executed.
We implemented our technique in a new tool called bbr. In this paper, we show that it can be used to replay bugs in long-running single-threaded programs starting from the middle of an execution. We show that bbr incurs low recording overhead (avg. of 10%) during program execution, which is much less than existing replay schemes. We also show that it can reproduce real bugs from web servers, database systems, and other common utilities
Towards a distributed real-time system for future satellite applications
Thesis (MScEng)--University of Stellenbosch, 2003.ENGLISH ABSTRACT: The Linux operating system and shared Ethernet are alternative technologies with the potential to
reduce both the development time and costs of satellites as well as the supporting infrastructure.
Modular satellites, ground stations and rapid proto typing testbeds also have a common
requirement for distributed real-time computation. The identified technologies were investigated
to determine whether this requirement could also be met.
Various real-time extensions and modifications are currently available for the Linux operating
system. A suitable open source real-time extension called Real-Time Application Interface
(RTAI) was selected for the implementation of an experimental distributed real-time system.
Experimental results showed that the RTAI operating system could deliver deterministic realtime
performance, but only in the absence of non-real-time load.
Shared Ethernet is currently the most popular and widely used commercial networking
technology. However, Ethernet wasn't developed to provide real-time performance. Several
methods have been proposed in literature to modify Ethernet for real-time communications. A
token passing protocol was found to be an effective and least intrusive solution. The Real-Time
Token (RTToken) protocol was designed to guarantee predictable network access to
communicating real-time tasks. The protocol passes a token between nodes in a predetermined
order and nodes are assigned fixed token holding times. Experimental results proved that the
protocol offered predictable network access with bounded jitter.
An experimental distributed real-time system was implemented, which included the extension of
the RTAI operating system with the RTToken protocol, as a loadable kernel module. Real-time
tasks communicated using connectionless Internet protocols. The Real-Time networking (RTnet)
subsystem of RTAI supported these protocols. Under collision-free conditions consistent
transmission delays with bounded jitter was measured. The integrated RTToken protocol
provided guaranteed and bounded network access to communicating real-time tasks, with limit
overheads. Tests exhibited errors in some of the RTAI functionality. Overall the investigated
technologies showed promise in being able to meet the distributed real-time requirements of
various applications, including those found in the satellite environment.AFRIKAANSE OPSOMMING: Die Linux bedryfstelsel en gedeelde Ethernet is geรฏdentifiseer as potensiรซle tegnologieรซ vir
satelliet bedryf wat besparings in koste en vinniger ontwikkeling te weeg kan bring. Modulรชr
ontwerpte satelliete, grondstasies en ontwikkeling platforms het 'n gemeenskaplike behoefte vir
verspreide intydse verwerking. Verskillende tegnologieรซ is ondersoek om te bepaal of aan die
vereiste ook voldoen kan word.
Verskeie intydse uitbreidings en modifikasies is huidiglik beskikbaar vir die Linux bedryfstelsel.
Die "Real-Time Application Interface" (RTAI) bedryfstelsel is geรฏdentifiseer as 'n geskikte
intydse uitbreiding vir die implementering van 'n eksperimentele verspreide intydse stelsel.
Eksperimentele resultate het getoon dat die RTAI bedryfstelsel deterministies en intyds kan
opereer, maar dan moet dit geskied in die afwesigheid van 'n nie-intydse verwerkingslas.
Gedeelde Ethernet is 'n kommersiรซle network tegnologie wat tans algemeen beskikbaar is. Die
tegnologie is egter nie ontwerp vir intydse uitvoering nie. Verskeie metodes is in die literatuur
voorgestelom Ethernet te modifiseer vir intydse kommunikasie. Hierdie ondersoek het getoon
dat 'n teken-aangee protokol die mees effektiewe oplossing is en waarvan die implementering
min inbreuk maak. Die "Real-Time Token" (RTToken) protokol is ontwerp om voorspelbare
netwerk toegang tot kommunikerende intydse take te verseker. Die protokol stuur 'n teken tussen
nodusse in 'n voorafbepaalde volgorde. Nodusse word ook vaste teken hou-tye geallokeer.
Eksperimentele resultate het aangedui dat die protokol deterministiese netwerk toegang kan
verseker met begrensde variasies.
'n Eksperimentele verspreide intydse stelsel is geรฏmplementeer. Dit het ingesluit die uitbreiding
van die RTAI bedryfstelsel met die RTToken protokol; verpak as 'n laaibare bedryfstelsel
module. Intydse take kan kommunikeer met verbindinglose protokolle wat deur die "Real-Time
networking" (RTnet) substelsel van RTAI ondersteun word. Onder ideale toestande is konstante
transmissie vertragings met begrensde variasies gemeet. Die integrasie van die RTToken
protokol het botsinglose netwerk toegang aan kommunikerende take verseker, met beperkte
oorhoofse koste as teenprestasie. Eksperimente het enkele foute in die funksionaliteit van RTAI
uitgewys. In die algemeen het die voorgestelde tegnologieรซ getoon dat dit potensiaal het vir
verskeie verspreide intydse toepassings in toekomstige satelliet en ook ander omgewings
Teadusarvutuse algoritmide taandamine hajusarvutuse raamistikele
Teadusarvutuses kasutatakse arvuteid ja algoritme selleks, et lahendada probleeme erinevates reaalteadustes nagu geneetika, bioloogia ja keemia. Tihti on eesmรคrgiks selliste loodusnรคhtuste modelleerimine ja simuleerimine, mida pรคris keskkonnas oleks vรคga raske uurida.
Nรคiteks on vรตimalik luua pรคikesetormi vรตi meteoriiditabamuse mudel ning arvutisimulatsioonide abil hinnata katastroofi mรตju keskkonnale. Mida keerulisemad ja tรคpsemad on sellised simulatsioonid, seda rohkem arvutusvรตimsust on vaja. Tihti kasutatakse selleks suurt hulka arvuteid, mis kรตik samaaegselt tรถรถtavad รผhe probleemi kallal. Selliseid arvutusi nimetatakse paralleel- vรตi hajusarvutusteks.
Hajusarvutuse programmide loomine on aga keeruline ning nรตuab palju rohkem aega ja ressursse, kuna vaja on sรผnkroniseerida erinevates arvutites samaaegselt tehtavat tรถรถd. On loodud mitmeid tarkvararaamistikke, mis lihtsustavad seda tรถรถd automatiseerides osa hajusprogrammeerimisest.
Selle teadustรถรถ eesmรคrk oli uurida selliste hajusarvutusraamistike sobivust keerulisemate teadusarvutuse algoritmide jaoks. Tulemused nรคitasid, et olemasolevad raamistikud on รผksteisest vรคga erinevad ning neist รผkski ei ole sobiv kรตigi erinevat tรผรผpi algoritmide jaoks. Mรตni raamistik on sobiv ainult lihtsamate algoritmide jaoks; mรตni ei sobi olukorras, kus andmed ei mahu arvutite mรคllu. Algoritmi jaoks kรตige sobivama hajusarvutisraamistiku valimine vรตib olla vรคga keeruline รผlesanne, kuna see nรตuab olemasolevate raamistike uurimist ja rakendamist.
Sellele probleemile lahendust otsides otsustati luua dรผnaamiline algoritmide modelleerimise rakendus (DAMR), mis oskab simuleerida algoritmi implementatsioone erinevates hajusarvutusraamistikes. DAMR aitab hinnata milline hajusraamistik on kรตige sobivam ette antud algoritmi jaoks, ilma algoritmi reaalselt รผhegi hajusraamistiku peale implementeerimata.
Selle uurimustรถรถ peamine panus on hajusarvutusraamistike kasutuselevรตtu lihtsamaks tegemine teadlastele, kes ei ole varem nende kasutamisega kokku puutunud. See peaks mรคrkimisvรครคrselt aega ja ressursse kokku hoidma, kuna ei pea รผkshaaval kรตiki olemasolevaid hajusraamistikke tundma รตppima ja rakendama.Scientific computing uses computers and algorithms to solve problems in various sciences such as genetics, biology and chemistry. Often the goal is to model and simulate different natural phenomena which would otherwise be very difficult to study in real environments.
For example, it is possible to create a model of a solar storm or a meteor hit and run computer simulations to assess the impact of the disaster on the environment. The more sophisticated and accurate the simulations are the more computing power is required. It is often necessary to use a large number of computers, all working simultaneously on a single problem. These kind of computations are called parallel or distributed computing.
However, creating distributed computing programs is complicated and requires a lot more time and resources, because it is necessary to synchronize different computers working at the same time. A number of software frameworks have been created to simplify this process by automating part of a distributed programming.
The goal of this research was to assess the suitability of such distributed computing frameworks for complex scientific computing algorithms. The results showed that existing frameworks are very different from each other and none of them are suitable for all different types of algorithms. Some frameworks are only suitable for simple algorithms; others are not suitable when data does not fit into the computer memory. Choosing the most appropriate distributed computing framework for an algorithm can be a very complex task, because it requires studying and applying the existing frameworks.
While searching for a solution to this problem, it was decided to create a Dynamic Algorithms Modelling Application (DAMA), which is able to simulate the implementation of the algorithm in different distributed computing frameworks. DAMA helps to estimate which distributed framework is the most appropriate for a given algorithm, without actually implementing it in any of the available frameworks.
This main contribution of this study is simplifying the adoption of distributed computing frameworks for researchers who are not yet familiar with using them. It should save significant time and resources as it is not necessary to study each of the available distributed computing frameworks in detail
- โฆ