Zeitschriftenartikel: „Multithreaded application“

1

Giebas, Damian, und Rafał Wojszczyk. „Deadlocks Detection in Multithreaded Applications Based on Source Code Analysis“. Applied Sciences 10, Nr. 2 (10.01.2020): 532. http://dx.doi.org/10.3390/app10020532.

Der volle Inhalt der Quelle

Annotation:

This paper extends multithreaded application source code model and shows how to using it to detect deadlocks in C language applications. Four known deadlock scenarios from literature can be detected using our model. For every scenario we created theorems and proofs whose fulfillment guarantees the occurrence of deadlocks in multithreaded applications. Paper also contains comparison of multithreaded application source code model and Petri nets and describe advantages and disadvantages both of them.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

2

Muralidhara, Sai Prashanth, Mahmut Kandemir und Padma Raghavan. „Intra-application shared cache partitioning for multithreaded applications“. ACM SIGPLAN Notices 45, Nr. 5 (Mai 2010): 329–30. http://dx.doi.org/10.1145/1837853.1693498.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

3

Shen, Hua, Guo Shun Zhou und Hui Qi Yan. „A Study of Parallelization and Performance Optimizations Based on OpenMP“. Applied Mechanics and Materials 321-324 (Juni 2013): 2933–37. http://dx.doi.org/10.4028/www.scientific.net/amm.321-324.2933.

Der volle Inhalt der Quelle

Annotation:

The primary consequence of the transition to multicore processors is that applications will increasingly need to be parallelized to improve application's throughput, responsiveness and latency. Multithreading is becoming increasingly important for modern programming. Unfortunately, parallel programming is no doubt much more tedious and error-prone than serial programming. Although modern compilers can manage threads well, but in practice, synchronization errors (such as: data race errors, deadlocks) required careful management and good optimization method. This paper presents a preliminary study of the usability of the Intel threading tools for multicore programming. This work compare performance of a single threaded application with multithreaded applications, use tools called Intel® VTune Performance Analyzer, Intel® Thread Checker and OpenMP to efficiently optimize multithreaded applications.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

4

Molchanov, Viktor. „Implementation of multithreaded calculations in educational web applications“. Development Management 17, Nr. 2 (26.07.2019): 1–7. http://dx.doi.org/10.21511/dm.17(2).2019.01.

Der volle Inhalt der Quelle

Annotation:

The complication of the logic of educational web applications raises the issue of the effectiveness of the organization of their implementation. At the same time, efficiency, including pedagogical one, is connected among other factors with the technology of implementation of programs. When using as the main browser program, it is necessary to take into account its features, in particular, one-flow mode of execution of programs (scripts). Implementation of more complex algorithms in web applications delays the response of the application interface to user actions. This creates a discomfort for the user and, as a result, reduces the effectiveness of his work. Expanding the range of devices from which users access the Internet leads to the fact that mobile devices are more and more often used for learning as well. Therefore, another side of the problem is the impact on the quality of connection to the server. It is necessary to ensure the work of the program in case of interruptions in connection or reduce their impact. A solution to the problem may be the implementation of part of the calculations in the background. The article deals with the use of calculations in the background streams of the browser and caching control for educational web applications. Various ways of creating such streams and the peculiarities of their use are analyzed.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

5

Eickemeyer, Richard J., Ross E. Johnson, Steven R. Kunkel, Mark S. Squillante und Shiafun Liu. „Evaluation of multithreaded uniprocessors for commercial application environments“. ACM SIGARCH Computer Architecture News 24, Nr. 2 (Mai 1996): 203–12. http://dx.doi.org/10.1145/232974.232994.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

6

Mao, Li Na, und Lin Yan Tang. „The Design and Application of Monitoring Framework Based on AOP“. Applied Mechanics and Materials 685 (Oktober 2014): 671–75. http://dx.doi.org/10.4028/www.scientific.net/amm.685.671.

Der volle Inhalt der Quelle

Annotation:

In this article apply AOP technology to multithreaded monitoring, using a database to store thread information multi-threaded monitoring platform implementation scheme, thread monitoring module is completely independent of the original system.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

7

Kama, Sami, Charles Leggett, Scott Snyder und Vakho Tsulaia. „The ATLAS multithreaded offline framework“. EPJ Web of Conferences 214 (2019): 05018. http://dx.doi.org/10.1051/epjconf/201921405018.

Der volle Inhalt der Quelle

Annotation:

In preparation for Run 3 of the LHC, scheduled to start in 2021, the ATLAS experiment is revising its offline software so as to better take advantage of machines with many cores. A major part of this effort is migrating the software to run as a fully multithreaded application, as this has been shown to significantly improve the memory scaling behavior. This note outlines changes made to the software framework to support this migration.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

8

Xue, Xiaozhen, Sima Siami-Namini und Akbar Siami Namin. „Testing Multi-Threaded Applications Using Answer Set Programming“. International Journal of Software Engineering and Knowledge Engineering 28, Nr. 08 (August 2018): 1151–75. http://dx.doi.org/10.1142/s021819401850033x.

Der volle Inhalt der Quelle

Annotation:

We introduce a technique to formally represent and specify race conditions in multithreaded applications. Answer set programming (ASP) is a logic-based knowledge representation paradigm to formally express belief acquired through reasoning in an application domain. The transparent and expressiveness representation of problems along with powerful non-monotonic reasoning power enable ASP to abstractly represent and solve some certain classes of NP hard problems in polynomial times. We use ASP to formally express race conditions and thus represent potential data races often occurred in multithreaded applications with shared memory models. We then use ASP to generate all possible test inputs and thread interleaving, i.e. scheduling, whose executions would result in deterministically exposing thread interleaving failures. We evaluated the proposed technique with some moderate sized Java programs, and our experimental results confirm that the proposed technique can practically expose common data races in multithreaded programs with low false positive rates. We conjecture that, in addition to generating threads scheduling whose execution order leads to the exposition of data races, ASP has several other applications in constraint-based software testing research and can be utilized to express and solve similar test case generation problems where constraints play a key role in determining the complexity of searches.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

9

Nagel, Everton, Ricardo Melo Czekster, Thais Webber und César Augusto Missio Marcon. „A Framework Prototype for Multithreaded Implementation Over Micro-Controllers“. Journal of Integrated Circuits and Systems 14, Nr. 1 (29.04.2019): 1–10. http://dx.doi.org/10.29292/jics.v14i1.39.

Der volle Inhalt der Quelle

Annotation:

Multithreading is pervasive in embedded system applications development. The applications requirements are becoming more rigorous, demanding the execution of concurrent tasks that must also take into account modularity and flexibility. An important part of the operating systems development concerns the implementation of scheduling algorithms. In an embedded system context, it is essential to consider that the scheduling algorithm heavily influences application behavior. Due to restricted and finite hardware resources, it is important to evaluate the use of flexible algorithms to guarantee efficiency. Currently, projects for embedded operating systems do exist for microcontrollers’ devices that implement scheduling algorithms, however, the developer cannot change or add new scheduling policies without implementing kernel tweaks and modifications. The alternatives are not flexible when choosing the scheduling algorithm according to the application needs. This imposes restrictions to many systems, forcing them to run specific static scheduling algorithms because no other options are available. The objective of this work concerns the design and development of a framework that implements a microkernel with a modular scheduler unit, allowing the execution of tailored algorithms according to the application profile. The idea is to provide a flexible platform to conveniently select the most appropriated algorithm. We have employed low capacity hardware to implement multithreading patterns corresponding to sets of concurrent tasks, demonstrating the strengths of adopting our approach. Our results show that the use of modern techniques that combine modularity, multithreading, and scheduling methods for embedded systems yield best executions when compared to its sequential counterparts.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

10

Tang, Xulong, Mahmut Taylan Kandemir und Mustafa Karakoy. „Mix and Match: Reorganizing Tasks for Enhancing Data Locality“. Proceedings of the ACM on Measurement and Analysis of Computing Systems 5, Nr. 2 (Juni 2021): 1–24. http://dx.doi.org/10.1145/3460087.

Der volle Inhalt der Quelle

Annotation:

Application programs that exhibit strong locality of reference lead to minimized cache misses and better performance in different architectures. However, to maximize the performance of multithreaded applications running on emerging manycore systems, data movement in on-chip network should also be minimized. Unfortunately, the way many multithreaded programs are written does not lend itself well to minimal data movement. Motivated by this observation, in this paper, we target task-based programs (which cover a large set of available multithreaded programs), and propose a novel compiler-based approach that consists of four complementary steps. First, we partition the original tasks in the target application into sub-tasks and build a data reuse graph at a sub-task granularity. Second, based on the intensity of temporal and spatial data reuses among sub-tasks, we generate new tasks where each such (new) task includes a set of sub-tasks that exhibit high data reuse among them. Third, we assign the newly-generated tasks to cores in an architecture-aware fashion with the knowledge of data location. Finally, we re-schedule the execution order of sub-tasks within new tasks such that sub-tasks that belong to different tasks but share data among them are executed in close proximity in time. The detailed experiments show that, when targeting a state of the art manycore system, our proposed compiler-based approach improves the performance of 10 multithreaded programs by 23.4% on average, and it also outperforms two state-of-the-art data access optimizations for all the benchmarks tested. Our results also show that the proposed approach i) improves the performance of multiprogrammed workloads, and ii) generates results that are close to maximum savings that could be achieved with perfect profiling information. Overall, our experimental results emphasize the importance of dividing an original set of tasks of an application into sub-tasks and constructing new tasks from the resulting sub-tasks in a data movement- and locality-aware fashion.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

11

AZAGURY, ALAIN, ELLIOT K. KOLODNER und EREZ PETRANK. „A NOTE ON THE IMPLEMENTATION OF REPLICATION-BASED GARBAGE COLLECTION FOR MULTITHREADED APPLICATIONS AND MULTIPROCESSOR ENVIRONMENTS“. Parallel Processing Letters 09, Nr. 03 (September 1999): 391–99. http://dx.doi.org/10.1142/s0129626499000360.

Der volle Inhalt der Quelle

Annotation:

Replication-based incremental garbage collection is one of the more appealing concurrent garbage collection algorithms known today. It allows continuous operation of the application (the mutator) with very short pauses for garbage collection. There is a growing need for such garbage collectors suitable for a multithreaded environments such as the Java Virtual Machine. Furthermore, it is desirable to construct collectors that also work on multiprocessor computers. We begin by pointing out an important, yet subtle point, which arises when implementing the replication-based garbage collector for a multithreaded environment. We first show that a simple and natural implementation of the algorithm may lead to an incorrect behavior of multithreaded applications. We then show that another simple and natural implementation eliminates the problem completely. Thus, the contribution of this part is in stressing this warning to future implementors. Next, we address the effects of the memory coherence model on this algorithm. We show that even when the algorithm is properly implemented with respect to our first observation, a problem might still arise when a multiprocessor system is used. Adopting a naive solution to this problem results in very frequent (and expensive) synchronization. We offer a slight modification to the algorithm which eliminates the problem and requires little synchronization.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

12

DAM, MADS, BART JACOBS, ANDREAS LUNDBLAD und FRANK PIESSENS. „Security monitor inlining and certification for multithreaded Java“. Mathematical Structures in Computer Science 25, Nr. 3 (17.12.2014): 528–65. http://dx.doi.org/10.1017/s0960129512000916.

Der volle Inhalt der Quelle

Annotation:

Security monitor inlining is a technique for security policy enforcement whereby monitor functionality is injected into application code in the style of aspect-oriented programming. The intention is that the injected code enforces compliance with the policy (security), and otherwise interferes with the application as little as possible (conservativity and transparency). Such inliners are said to be correct. For sequential Java-like languages, inlining is well understood, and several provably correct inliners have been proposed. For multithreaded Java one difficulty is the need to maintain a shared monitor state. We show that this problem introduces fundamental limitations in the type of security policies that can be correctly enforced by inlining. A class of race-free policies is identified that precisely characterizes the inlineable policies by showing that inlining of a policy outside this class is either not secure or not transparent, and by exhibiting a concrete inliner for policies inside the class which is secure, conservative and transparent. The inliner is implemented for Java and applied to a number of practical application security policies. Finally, we discuss how certification in the style of proof-carrying code could be supported for inlined programs by using annotations to reduce a potentially complex verification problem for multithreaded Java bytecode to sequential verification of just the inlined code snippets.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

13

Albertian, A. M., und I. I. Kurochkin. „Use of specialized computational devices on the node of the desktop grid system for the solve of combinatorial problems.“ Transaction Kola Science Centre 11, Nr. 8-2020 (16.12.2020): 105–10. http://dx.doi.org/10.37614/2307-5252.2020.8.11.010.

Der volle Inhalt der Quelle

Annotation:

The paper discusses the use of specialized Intel Xeon Phi devices in a desktop grid system. As an example of the successful use of specialized devices, the combinatorial problem of finding diagonal Latin squares is given. Features of implementation of the computing application are discussed. The results of work of a computer application in multithreaded modes on different processors andspecialized devices are given.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

14

S.K, SRIVATSA, und RAVI KUMAR CH. „RECONFIGURABLE FRAME WORK FOR CHIPMULTIPROCESSORS AND ITS APPLICATION IN MULTITHREADED ENVIRONMENT“. International Journal on Information Sciences and Computing 6, Nr. 1 (2012): 41–47. http://dx.doi.org/10.18000/ijisac.50111.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

15

Pashchenko, Dmitry V., Dmitry A. Trokoz, Alexey I. Martyshkin, Tatyana Yu Pashchenko, Mikhail M. Butaev und Mikhail Yu Babich. „Research of a multithreaded non-deterministic system model“. Nexo Revista Científica 34, Nr. 01 (13.04.2021): 193–204. http://dx.doi.org/10.5377/nexo.v34i01.11297.

Der volle Inhalt der Quelle

Annotation:

Managing the systems which behaviour is non-deterministic is one of the most important problems in modern management theory. Today, systems with structural and behavioural complexity are prevalent in all areas of human activity, and therefore, their research is of the utmost importance. Such systems, as opposed to deterministic systems, are called non-deterministic. They are characterised by difficult predictable behaviour determined both by external random influences, and within the systems themselves. A clear example of a non-deterministic system is crowds of people, factories, and computer networks and systems. The problem of non-deterministic behaviour directly within the context of professional activities can be seen using an example of building syntactic analysers. The aim of the paper is to design a class of systems oriented towards supporting elements of a discrete event model. The target of research is to simulate discrete event models. The subject of research is a creation of a discrete event model based on the behaviour of an undetermined finite state automaton. During the preparation of the paper, there was developed and practically implemented an algorithm for the application, which materializes the principle of working with threads. The results obtained in the paper are aimed at solving the problem of parallel data processing based on the parallelism of NFA's (non-deterministic finite automaton) behaviour when reading the input string characters. As a result, this should have a positive impact on the regulation of the simulation processes of a non-deterministic system, increasing its efficiency and stability. In conclusion, the algorithm of the application work is disclosed and conclusions about the effectiveness and efficiency of its development are drawn.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

16

Sun, Ya Juan, Hong Lin und Bao Hui Wang. „Research and Application on Optimization of Multi-Thread Download Technology for Enhanced Search Engine“. Advanced Materials Research 756-759 (September 2013): 1008–12. http://dx.doi.org/10.4028/www.scientific.net/amr.756-759.1008.

Der volle Inhalt der Quelle

Annotation:

Multi-threaded file download as the key technology of content acquisition system for search engine, determines the efficiency and timeliness of content acquisition. In this paper, we do the research on optimization technologies which include multithreaded download based on P2SP, task scheduling based on MapReduce and download based on the protocol adaptation, designed to improve enhanced search engine efficiency. At last the result shows that the optimization method is successful for content acquisition.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

17

Karasik, O. N., und A. A. Prihozhy. „ADVANCED SCHEDULER FOR COOPERATIVE EXECUTION OF THREADS ON MULTI-CORE SYSTEM“. «System analysis and applied information science», Nr. 1 (04.05.2017): 4–11. http://dx.doi.org/10.21122/2309-4923-2017-1-4-11.

Der volle Inhalt der Quelle

Annotation:

Three architectures of the cooperative thread scheduler in a multithreaded application that is executed on a multi-core system are considered. Architecture A0 is based on the synchronization and scheduling facilities, which are provided by the operating system. Architecture A1 introduces a new synchronization primitive and a single queue of the blocked threads in the scheduler, which reduces the interaction activity between the threads and operating system, and significantly speed up the processes of blocking and unblocking the threads. Architecture A2 replaces the single queue of blocked threads with dedicated queues, one for each of the synchronizing primitives, extends the number of internal states of the primitive, reduces the inter- dependence of the scheduling threads, and further significantly speeds up the processes of blocking and unblocking the threads. All scheduler architectures are implemented on Windows operating systems and based on the User Mode Scheduling. Important experimental results are obtained for multithreaded applications that implement two blocked parallel algorithms of solving the linear algebraic equation systems by the Gaussian elimination. The algorithms differ in the way of the data distribution among threads and by the thread synchronization models. The number of threads varied from 32 to 7936. Architecture A1 shows the acceleration of up to 8.65% and the architecture A2 shows the acceleration of up to 11.98% compared to A0 architecture for the blocked parallel algorithms computing the triangular form and performing the back substitution. On the back substitution stage of the algorithms, architecture A1 gives the acceleration of up to 125%, and architecture A2 gives the acceleration of up to 413% compared to architecture A0. The experiments clearly show that the proposed architectures, A1 and A2 outperform A0 depending on the number of thread blocking and unblocking operations, which happen during the execution of multi-threaded applications. The conducted computational experiments demonstrate the improvement of parameters of multithreaded applications on a heterogeneous multi-core system due the proposed advanced versions of the thread scheduler.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

18

Yu, Qian, Tong Li, Zhong Wen Xie, Na Zhao und Ying Lin. „Distributed Computing Design Methods for Multicore Application Programming“. Advanced Materials Research 756-759 (September 2013): 1295–99. http://dx.doi.org/10.4028/www.scientific.net/amr.756-759.1295.

Der volle Inhalt der Quelle

Annotation:

In order to solve the serial execution caused by multithreaded concurrent access to shared data and realize the dynamic load balance of tasks on shared memory symmetric multi-processor (multi-core) computing platform, new design methods are presented. By presenting multicore distributed locks, multicore shared data localization, multicore distributed queue, the new design methods can greatly decrease the number of accessing the shared data and realize the dynamic load balance of tasks. For illustration, design scheme of multicore task manager of server software are given by using new design methods. Results shows the new design methods reduce the number of access shared resources, partially resolve the serial execution of cooperative threads and realize the dynamic task balance of server software, which validate the superiority of this approach.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

19

Hamad, Faten, und Abdelsalam Alawamrah. „Measuring the Performance of Parallel Information Processing in Solving Linear Equation Using Multiprocessor Supercomputer“. Modern Applied Science 12, Nr. 3 (27.02.2018): 74. http://dx.doi.org/10.5539/mas.v12n3p74.

Der volle Inhalt der Quelle

Annotation:

Evaluation the performance of the algorithms and the method that is used to implement it play a major role in the assessment of the performance of many applications and it help the researchers to decide which algorithm to use and which method to implement it, it also give indicate of the performance of the hardware that the algorithm is tested over. In this paper we evaluate the performance of solving linear equation application over supercomputer which was implemented and using Message Passing interface (MPI) library. The sequential and multithreaded algorithm for solving linear equations has been experimented too and the results has been recorded, the speedup and efficiency of the algorithm has been calculated and the results showed that the parallel algorithm outperforms other methods with the large size matrix of 8192 * 8192 over the number of processors of 64. For large input size, the results also showed that there is a noticeable decrease in running time as the number of processors increase. But in case of multithreaded the results showed that as the matrix size increase the time required for running the algorithm is rapidly increasing although the number of threads increased. This indicates that the parallel performance over for large matrix input size is better and outperforms other methods.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

20

NATARAJAN, RAGAVENDRA, VINEETH MEKKAT, WEI-CHUNG HSU und ANTONIA ZHAI. „EFFECTIVENESS OF COMPILER-DIRECTED PREFETCHING ON DATA MINING BENCHMARKS“. Journal of Circuits, Systems and Computers 21, Nr. 02 (April 2012): 1240006. http://dx.doi.org/10.1142/s0218126612400063.

Der volle Inhalt der Quelle

Annotation:

For today's increasingly power-constrained multicore systems, integrating simpler and more energy-efficient in-order cores becomes attractive. However, since in-order processors lack complex hardware support for tolerating long-latency memory accesses, developing compiler technologies to hide such latencies becomes critical. Compiler-directed prefetching has been demonstrated effective on some applications. On the application side, a large class of data centric applications has emerged to explore the underlying properties of the explosively growing data. These applications, in contrast to traditional benchmarks, are characterized by substantial thread-level parallelism, complex and unpredictable control flow, as well as intensive and irregular memory access patterns. These applications are expected to be the dominating workloads on future microprocessors. Thus, in this paper, we investigated the effectiveness of compiler-directed prefetching on data mining applications in in-order multicore systems. Our study reveals that although properly inserted prefetch instructions can often effectively reduce memory access latencies for data mining applications, the compiler is not always able to exploit this potential. Compiler-directed prefetching can become inefficient in the presence of complex control flow and memory access patterns; and architecture dependent behaviors. The integration of multithreaded execution onto a single die makes it even more difficult for the compiler to insert prefetch instructions, since optimizations that are effective for single-threaded execution may or may not be effective in multithreaded execution. Thus, compiler-directed prefetching must be judiciously deployed to avoid creating performance bottlenecks that otherwise do not exist. Our experiences suggest that dynamic performance tuning techniques that adjust to the behaviors of a program can potentially facilitate the deployment of aggressive optimizations in data mining applications.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

21

Theobald, Kevin B., Rishi Kumar, Gagan Agrawal, Gerd Heber, Ruppa K. Thulasiram und Guang R. Gao. „Implementation and evaluation of a communication intensive application on the EARTH multithreaded system“. Concurrency and Computation: Practice and Experience 14, Nr. 3 (2002): 183–201. http://dx.doi.org/10.1002/cpe.604.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

22

Mori, Shinichiro, Masanao Kobayashi, Motoki Kumagai und Shinichi Minohara. „Development of a GPU-based multithreaded software application to calculate digitally reconstructed radiographs for radiotherapy“. Radiological Physics and Technology 2, Nr. 1 (Januar 2009): 40–45. http://dx.doi.org/10.1007/s12194-008-0040-3.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

23

GRELCK, CLEMENS, und SVEN-BODO SCHOLZ. „SAC — FROM HIGH-LEVEL PROGRAMMING WITH ARRAYS TO EFFICIENT PARALLEL EXECUTION“. Parallel Processing Letters 13, Nr. 03 (September 2003): 401–12. http://dx.doi.org/10.1142/s0129626403001379.

Der volle Inhalt der Quelle

Annotation:

SAC is a purely functional array processing language designed with numerical applications in mind. It supports generic, high-level program specifications in the style of APL. However, rather than providing a fixed set of built-in array operations, SAC provides means to specify such operations in the language itself in a way that still allows their application to arrays of any rank and size. This paper illustrates the major steps in compiling generic, rank- and shape-invariant SAC specifications into efficiently executable multithreaded code for parallel execution on shared memory multiprocessors. The effectiveness of the compilation techniques is demonstrated by means of a small case study on the PDE1 benchmark, which implements 3-dimensional red/black successive over-relaxation. Comparisons with HPF and ZPL show that despite the genericity of code, SAC achieves highly competitive runtime performance characteristics.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

24

Ngo, Hieu Khanh, und Grolleau Emmanuel. „DARTSVIEW, A TOOLKIT FOR DARTS IN LABVIEW“. Science and Technology Development Journal 12, Nr. 14 (15.08.2009): 69–76. http://dx.doi.org/10.32508/stdj.v12i14.2341.

Der volle Inhalt der Quelle

Annotation:

DARTS (Design Approach for Real Time Systems) [4] is a software design method for real time systems. LabVIEW (Laboratory Virtual Instrument Engineering Workbench) is a graphical application development environment developed by National Instruments Corporation based on the dataflow representation of the "G" language [6][2]. LabVIEW is implicitly multithreaded and has high level functions for communication/synchronization, allowing it to be used as a programming language for control/command and soft real-time applications. In order to help a designer to develop a real-time application, we propose the library DARTSVIEW, which simplifies the passage from the conception of a "multitasking" application to the implementation [8). One can use DARTSVIEW in different phases of the life cycle of real-time system software. The last version of DARTSVIEW, allows to define in XML several real-time programming normalized languages, and to generate a part of the code for different specific programming languages (Ada, POSIX 1003.1, VxWorks, OSEK/VDX, etc.). The flexibility introduced by the use of XML allows a designer also to generate some code targeting real-time scheduling analysis tools in order to achieve the temporal validation. The objective of this article is to present an overview of DARTSVIEW, a Toolkit for DARTS in LabVIEW, the role of DARTSVIEW in the software.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

25

Saravanan, G., und N. Yuvaraj. „Cloud resource optimization based on poisson linear deep gradient learning for mobile cloud computing“. Journal of Intelligent & Fuzzy Systems 40, Nr. 1 (04.01.2021): 787–97. http://dx.doi.org/10.3233/jifs-200799.

Der volle Inhalt der Quelle

Annotation:

Mobile Cloud Computing (MCC) addresses the drawbacks of Mobile Users (MU) where the in-depth evaluation of mobile applications is transferred to a centralized cloud via a wireless medium to reduce load, therefore optimizing resources. In this paper, we consider the resource (i.e., bandwidth and memory) allocation problem to support mobile applications in a MCC environment. In such an environment, Mobile Cloud Service Providers (MCSPs) form a coalition to create a resource pool to share their resources with the Mobile Cloud Users. To enhance the welfare of the MCSPs, a method for optimal resource allocation to the mobile users called, Poisson Linear Deep Resource Allocation (PL-DRA) is designed. For resource allocation between mobile users, we formulate and solve optimization models to acquire an optimal number of application instances while meeting the requirements of mobile users. For optimal application instances, the Poisson Distributed Queuing model is designed. The distributed resource management is designed as a multithreaded model where parallel computation is provided. Next, a Linear Gradient Deep Resource Allocation (LG-DRA) model is designed based on the constraints, bandwidth, and memory to allocate mobile user instances. This model combines the advantage of both decision making (i.e. Linear Programming) and perception ability (i.e. Deep Resource Allocation). Besides, a Stochastic Gradient Learning is utilized to address mobile user scalability. The simulation results show that the Poisson queuing strategy based on the improved Deep Learning algorithm has better performance in response time, response overhead, and energy consumption than other algorithms.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

26

Guerra, Jorge, Hajime Nobuhara und Kaoru Hirota. „Fuzzy Configuration Space for Moving Obstacle Avoidance of Autonomous Mobile Robots“. Journal of Advanced Computational Intelligence and Intelligent Informatics 10, Nr. 1 (20.01.2006): 26–34. http://dx.doi.org/10.20965/jaciii.2006.p0026.

Der volle Inhalt der Quelle

Annotation:

A fuzzy configuration space description method that provides the path planning solution for autonomous mobile robots in dynamically changing environment is proposed based on a hybrid planning algorithm that combines total solutions and reactive control through fuzzy proximity measures. The system (made with C++) that monitors and controls mobile robots remotely is created using a multithreaded model while taking advantage of high performance OpenGL routines to counter the increase in computational cost generated by this approach. Experiments on a real Lego robot are performed using a personal computer with a 1.5GHz Pentium4 CPU and a CCD camera. The efficiency of the hybrid algorithm and the potential of this approach, as a distributed system, in greatly changing dynamic environments are shown. The system provides a starting point for further development of distributed robotic systems, for application in human support tasks where interaction with nonprecise human behaviors are better mentioned with fuzzy parameters.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

27

Malek, Maximilian, und Christoph W. Sensen. „Instant Feedback Rapid Prototyping for GPU-Accelerated Computation, Manipulation, and Visualization of Multidimensional Data“. International Journal of Biomedical Imaging 2018 (03.06.2018): 1–9. http://dx.doi.org/10.1155/2018/2046269.

Der volle Inhalt der Quelle

Annotation:

Objective. We have created an open-source application and framework for rapid GPU-accelerated prototyping, targeting image analysis, including volumetric images such as CT or MRI data. Methods. A visual graph editor enables the design of processing pipelines without programming. Run-time compiled compute shaders enable prototyping of complex operations in a matter of minutes. Results. GPU-acceleration increases processing the speed by at least an order of magnitude when compared to traditional multithreaded CPU-based implementations, while offering the flexibility of scripted implementations. Conclusion. Our framework enables real-time, intuition-guided accelerated algorithm and method development, supported by built-in scriptable visualization. Significance. This is, to our knowledge, the first tool for medical data analysis that provides both high performance and rapid prototyping. As such, it has the potential to act as a force multiplier for further research, enabling handling of high-resolution datasets while providing quasi-instant feedback and visualization of results.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

28

Machado, Iar, Michael Stanton und Tiago Salmito. „Internet Protocol Version 6 (IPv6) - Internet Protocol Version 4 (IPv4) Network Address, Port & Protocol Translation And Multithreaded DNS-Application Gateway“. Proceedings of the Asia-Pacific Advanced Network 31 (01.06.2011): 12. http://dx.doi.org/10.7125/apan.31.2.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

29

Singh, Abhinav, Navpreet Singh und Vinay Bajpai. „Internet Protocol Version 6 (IPv6) - Internet Protocol Version 4 (IPv4) Network Address, Port & Protocol Translation And Multithreaded DNS-Application Gateway“. Proceedings of the Asia-Pacific Advanced Network 31 (01.06.2011): 12. http://dx.doi.org/10.7125/apan.31.21.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

30

Trunov, Artem S., Vyacheslav I. Voronov und Lilia I. Voronova. „Integration of legacy applications into "Eni" scientific research ecosystem“. T-Comm 14, Nr. 8 (2020): 33–41. http://dx.doi.org/10.36724/2072-8735-2020-14-8-33-41.

Der volle Inhalt der Quelle

Annotation:

The article describes the development of a digital platform for the Eni research ecosystem, based on a microservice approach that automatically scales the computing resources of the system when working with big data. A brief description of the structure of the digital platform, its main components and the functionality of the basic subsystems is provided. Two types of digital platform consumers are presented - legacy and platform applications. Their capabilities and limitations are shown. The subsystem of distributed computing is described, which provides continuous management and monitoring of the microservice architecture of the platform, in particular, it is responsible for: load balancing, service discovery, system recovery after failures, end-to-end authentication, "canary rollouts", access control. The high-performance computing subsystem is presented. It includes models and methods for organizing parallel calculations on various hardware devices, such as a multiprocessor system, a cluster of computing devices connected by a local network, and a graphics processor. As software solutions for organizing parallel computing, multithreaded data processing technologies, MPI messaging interface, and CUDA technology are used. Also described is a data mining subsystem designed to deploy different types of neural networks with different architectures, including direct distribution, convolutional, recurrent and generative neural networks. The integration of the legacy application MD-SLAG-MELT v13.0 into the ecosystem of scientific research using platform integration adapters is presented. The architectures and the main components of the original software package and the integrated software package MD-SLAG-MELT v14.0 are presented. The results of load testing with the analysis of performance metrics and response time of an inherited application, when processing big data, are presented.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

31

Nikolaev, P. M. „Improving the Efficiency of Calculating B-splines in parallel Programming Tasks“. Programmnaya Ingeneria 12, Nr. 5 (06.08.2021): 267–73. http://dx.doi.org/10.17587/prin.12.267-273.

Der volle Inhalt der Quelle

Annotation:

The use of parallel computing tools can significantly reduce the execution time of calculations in many engineering tasks. One of the main difficulties in the development of multithreaded programs remains the organization of simultaneous access from different threads to shared data. The most common solution to this problem is to use locking facilities when accessing shared data. There are a number of tasks where data sharing is not needed, but you need to synchronize access to a limited resource, such as a temporary buffer. In such tasks, there is no data exchange between different threads, but there is an object that at a given time can be used by the code of only one thread. One such task is calculating the value of a B-spline. The software implementation of the functions for calculating B-splines, performed according to classical algorithms, requires the use of blocking objects when accessing the common array of intermediate data from different threads. This reduces the degree of parallelism and reduces the efficiency of computational programs using B-splines running on multiprocessor computing systems. The article discusses a way to improve the efficiency of calculating B-splines in parallel programming tasks by eliminating locks when accessing general modified data. A software implementation is presented in the form of a C++ class template, which provides placement of a temporary array used for calculating a B-spline into a local buffer of a given size with the possibility of increasing it if necessary. Using the developed template in conjunction with the threadlocal qualifier reduces the number of requests for increasing the buffer for high degree B-splines (larger than the initially specified buffer size). It is also possible to implement this scheme using the std::vector template of the C++ STL Standard Library. The results of the application of the developed class when calculating the values of B-splines in a multithreaded environment, showing a reduction in the calculation time in proportion to an increase in the number of computational processors, are presented. The methods of specifying arrays for storing intermediate calculation results considered in this article can be used in other parallel programming tasks.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

32

Zenkov, I. V., A. V. Lapko, V. A. Lapko, S. T. Im, V. P. Tuboltsev und V. L. Аvdeenok. „A nonparametric algorithm for automatic classification of large multivariate statistical data sets and its application“. Computer Optics 45, Nr. 2 (April 2021): 253–60. http://dx.doi.org/10.18287/2412-6179-co-801.

Der volle Inhalt der Quelle

Annotation:

A nonparametric algorithm for automatic classification of large statistical data sets is proposed. The algorithm is based on a procedure for optimal discretization of the range of values of a random variable. A class is a compact group of observations of a random variable corresponding to a unimodal fragment of the probability density. The considered algorithm of automatic classification is based on the «compression» of the initial information based on the decomposition of a multidimensional space of attributes. As a result, a large statistical sample is transformed into a data array composed of the centers of multidimensional sampling intervals and the corresponding frequencies of random variables. To substantiate the optimal discretization procedure, we use the results of a study of the asymptotic properties of a kernel-type regression estimate of the probability density. An optimal number of sampling intervals for the range of values of one- and two-dimensional random variables is determined from the condition of the minimum root-mean square deviation of the regression probability density estimate. The results obtained are generalized to the discretization of the range of values of a multidimensional random variable. The optimal discretization formula contains a component that is characterized by a nonlinear functional of the probability density. An analytical dependence of the detected component on the antikurtosis coefficient of a one-dimensional random variable is established. For independent components of a multidimensional random variable, a methodology is developed for calculating estimates of the optimal number of sampling intervals for random variables and their lengths. On this basis, a nonparametric algorithm for the automatic classification is developed. It is based on a sequential procedure for checking the proximity of the centers of multidimensional sampling intervals and relationships between frequencies of the membership of the random variables from the original sample of these intervals. To further increase the computational efficiency of the proposed automatic classification algorithm, a multithreaded method of its software implementation is used. The practical significance of the developed algorithms is confirmed by the results of their application in processing remote sensing data.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

33

Omma, M. „On building multithreaded applications“. IEEE Distributed Systems Online 5, Nr. 4 (April 2004): 1–3. http://dx.doi.org/10.1109/mdso.2004.1301256.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

34

Giebas, Damian, und Rafał Wojszczyk. „Atomicity Violation in Multithreaded Applications and Its Detection in Static Code Analysis Process“. Applied Sciences 10, Nr. 22 (12.11.2020): 8005. http://dx.doi.org/10.3390/app10228005.

Der volle Inhalt der Quelle

Annotation:

This paper is a contribution to the field of research dealing with the parallel computing, which is used in multithreaded applications. The paper discusses the characteristics of atomicity violation in multithreaded applications and develops a new definition of atomicity violation based on previously defined relationships between operations, that can be used to atomicity violation detection. A method of detection of conflicts causing atomicity violation was also developed using the source code model of multithreaded applications that predicts errors in the software.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

35

Hˇrivnácˇová, Ivana. „FairRoot and ALICE O2 Multithreading Simulation“. EPJ Web of Conferences 214 (2019): 02018. http://dx.doi.org/10.1051/epjconf/201921402018.

Der volle Inhalt der Quelle

Annotation:

To address the challenges of the major upgrade of the experiment, the ALICE simulations must be able to make efficient use of computing and opportunistic supercomputing resources available on the GRID. The Geant4 transport package, the performance of which has been demonstrated in a hybrid multithreading (MT) and multiprocessing (MPI) environment with up to 1/4 million threads, is therefore of a particular interest. The O2 simulation framework is based on FairRoot, which itself is based on the Virtual Monte Carlo (VMC). The integration of multithreading into the VMC design and its impact on the Geant4 VMC were presented at CHEP 2014. Geant4 VMC multithreading and the scaling behaviour of the computing time with the number of cores have then been tested using a simplified but realistic multithreaded simulation application. The focus was then put on the integration of multithreading in FairRoot classes as the necessary step towards multithreading in the FairRoot-based experimental frameworks. The new O2 framework is the first one of which the migration to multithreading is achieved for all actually included detectors. In this paper we present the progress with the integration of multithreading in FairRoot classes, the work for thread-safety in the O2 simulation classes and the experience with the integration of the multithreading mode in testing. We will also discuss plans for the further developments.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

36

Radojkovic, Petar, Vladimir Cakarevic, Javier Verdu, Alex Pajuelo, Francisco J. Cazorla, Mario Nemirovsky und Mateo Valero. „Thread Assignment of Multithreaded Network Applications in Multicore/Multithreaded Processors“. IEEE Transactions on Parallel and Distributed Systems 24, Nr. 12 (Dezember 2013): 2513–25. http://dx.doi.org/10.1109/tpds.2012.311.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

37

Basile, C., Z. Kalbarczyk und R. K. Iyer. „Active replication of multithreaded applications“. IEEE Transactions on Parallel and Distributed Systems 17, Nr. 5 (Mai 2006): 448–65. http://dx.doi.org/10.1109/tpds.2006.56.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

38

Baliś, Bartosz, Marian Bubak, Włodzimierz Funika und Roland Wismüller. „A monitoring system for multithreaded applications“. Future Generation Computer Systems 19, Nr. 5 (Juli 2003): 641–50. http://dx.doi.org/10.1016/s0167-739x(02)00174-7.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

39

Tallent, Nathan R., John M. Mellor-Crummey und Allan Porterfield. „Analyzing lock contention in multithreaded applications“. ACM SIGPLAN Notices 45, Nr. 5 (Mai 2010): 269–80. http://dx.doi.org/10.1145/1837853.1693489.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

40

Wheeler, Kyle B., und Douglas Thain. „Visualizing massively multithreaded applications with ThreadScope“. Concurrency and Computation: Practice and Experience 22, Nr. 1 (Januar 2010): 45–67. http://dx.doi.org/10.1002/cpe.1469.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

41

Schweitzer, P., S. Cipière, A. Dufaure, H. Payno, Y. Perrot, D. R. C. Hill und L. Maigne. „Performance Evaluation of Multithreaded Geant4 Simulations Using an Intel Xeon Phi Cluster“. Scientific Programming 2015 (2015): 1–10. http://dx.doi.org/10.1155/2015/980752.

Der volle Inhalt der Quelle

Annotation:

The objective of this study is to evaluate the performances of Intel Xeon Phi hardware accelerators for Geant4 simulations, especially for multithreaded applications. We present the complete methodology to guide users for the compilation of their Geant4 applications on Phi processors. Then, we propose series of benchmarks to compare the performance of Xeon CPUs and Phi processors for a Geant4 example dedicated to the simulation of electron dose point kernels, the TestEm12 example. First, we compare a distributed execution of a sequential version of the Geant4 example on both architectures before evaluating the multithreaded version of the Geant4 example. If Phi processors demonstrated their ability to accelerate computing time (till a factor 3.83) when distributing sequential Geant4 simulations, we do not reach the same level of speedup when considering the multithreaded version of the Geant4 example.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

42

Krasowski, Piotr, und Jakub Smołka. „Performance testing of STL and Qt library elements in multi-threaded processing“. Journal of Computer Sciences Institute 16 (30.09.2020): 247–51. http://dx.doi.org/10.35784/jcsi.2007.

Der volle Inhalt der Quelle

Annotation:

In recent years multithreaded processing has become a important programming aspect. Computers with a multi-core processor are now widely available, enabling the creation of more efficient applications. Many libraries support multithreaded solutions, but performance information is often lacking. The use of appropriate data structures and algorithms significantly speeds up the process of creation and development of applications. Article describes selected elements of the Qt and STL library and compares their performance in concurrent programming. The time needed to perform individual operations was analysed.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

43

Wang, Yufeng, Hui Zhou, Xuebin Zhao, Qingchen Zhang, Poru Zhao, Xiance Yu und Yangkang Chen. „CuQ-RTM: A CUDA-based code package for stable and efficient Q-compensated reverse time migration“. GEOPHYSICS 84, Nr. 1 (01.01.2019): F1—F15. http://dx.doi.org/10.1190/geo2017-0624.1.

Der volle Inhalt der Quelle

Annotation:

Reverse time migration (RTM) in attenuating media should take absorption and dispersion effects into consideration. The latest proposed viscoacoustic wave equation with decoupled fractional Laplacians facilitates separate amplitude compensation and phase correction in [Formula: see text]-compensated RTM ([Formula: see text]-RTM). However, intensive computation and enormous storage requirements of [Formula: see text]-RTM prevent it from being extended into practical application, especially for large-scale 2D or 3D cases. The emerging graphics processing unit (GPU) computing technology, built around a scalable array of multithreaded streaming multiprocessors, presents an opportunity for greatly accelerating [Formula: see text]-RTM by appropriately exploiting GPUs architectural characteristics. We have developed the cu[Formula: see text]-RTM, a CUDA-based code package that implements [Formula: see text]-RTM based on a set of stable and efficient strategies, such as streamed CUDA fast Fourier transform, checkpointing-assisted time-reversal reconstruction, and adaptive stabilization. The cu[Formula: see text]-RTM code package can run in a multilevel parallelism fashion, either synchronously or asynchronously, to take advantages of all the CPUs and GPUs available, while maintaining impressively good stability and flexibility. We mainly outline the architecture of the cu[Formula: see text]-RTM code package and some program optimization schemes. The speedup ratio on a single GeForce GTX760 GPU card relative to a single core of Intel Core i5-4460 CPU can reach greater than 80 in a large-scale simulation. The strong scaling property of multi-GPU parallelism is demonstrated by performing [Formula: see text]-RTM on a Marmousi model with one to six GPU(s) involved. Finally, we further verified the feasibility and efficiency of the cu[Formula: see text]-RTM on a field data set.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

44

Egorov, Mikhail, Dmitry Egorov und Sergey Egorov. „NUMERICAL STUDY OF DYNAMICS INTRACHAMBER PROCESSES IN SOLID PROPELLANT SUSTAINER TAKING INTO ACCOUNT FLIGHT OVERLOADS. PART 1. CALCULATION METHOD“. Perm National Research Polytechnic University Aerospace Engineering Bulletin, Nr. 64 (2021): 91–103. http://dx.doi.org/10.15593/2224-9982/2021.64.10.

Der volle Inhalt der Quelle

Annotation:

The dynamics of transient in-chamber processes (internal ballistics) of the cruise missile's second-stage cruise missile propulsion system is studied, taking into account, in the general case, distributed spatially-three-dimensional and time-varying flight overloads. The research method is the formulation of a computational experiment. Be considered coupled formulation of the problem, including: – transient triggering of igniter device (the rate of combustion of the igniting composition is described on the basis of experimental and theoretical approach afterburn combustion products in case igniting device); preheating, ignition and subsequent unsteady and turbulent combustion of solid propellant charge (used quasi-homogeneous combustion model based on the equations of heat conduction and chemical kinetics recorded for a condensed phase (solid fuel), taking into account the influence of the gas phase (torch) on the process of combustion in the condensed phase; the method of solving the problem – finite difference method); – non-stationary three-dimensional homogeneous-heterogeneous four phase flow of air and products of combustion in the combustion chamber, the nozzle block and the block launchers rocket engine (used approaches of continuum mechanics of multiphase media; the basic system of equations system of vortex differential equations of gas dynamics solution method – a multi-parameter class of difference schemes of splitting into physical processes of the method Davydova); – depressurization of the combustion chamber of the SRB (equation of motion of the plug nozzle block – Newton's second law; the proposed solution method – Euler's method). Each of the subtasks is considered in a relationship and resolved simultaneously – at one time step. To solve the formulated problem, a set of application programs has been developed using (for the main calculation module) the OpenCL multithreaded information processing standard. The performance of the software product was checked.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

45

Pandey, Swati. „INFORMATION FLOW SECURITY IN MULTITHREADED JAVA APPLICATIONS.“ International Journal of Advanced Research 5, Nr. 5 (31.05.2017): 1146–57. http://dx.doi.org/10.21474/ijar01/4225.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

46

Joao, José A., M. Aater Suleman, Onur Mutlu und Yale N. Patt. „Bottleneck identification and scheduling in multithreaded applications“. ACM SIGARCH Computer Architecture News 40, Nr. 1 (18.04.2012): 223–34. http://dx.doi.org/10.1145/2189750.2151001.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

47

Chlipala, Adam. „From Network Interface to Multithreaded Web Applications“. ACM SIGPLAN Notices 50, Nr. 1 (11.05.2015): 609–22. http://dx.doi.org/10.1145/2775051.2677003.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

48

Joao, José A., M. Aater Suleman, Onur Mutlu und Yale N. Patt. „Bottleneck identification and scheduling in multithreaded applications“. ACM SIGPLAN Notices 47, Nr. 4 (Juni 2012): 223–34. http://dx.doi.org/10.1145/2248487.2151001.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

49

BEDNORZ, M., A. GWOZDOWSKI und K. ZIELIŃSKI. „Contextual debugging and analysis of multithreaded applications“. Concurrency: Practice and Experience 9, Nr. 2 (Februar 1997): 123–39. http://dx.doi.org/10.1002/(sici)1096-9128(199702)9:2<123::aid-cpe242>3.0.co;2-l.

Der volle Inhalt der Quelle

APA, Harvard, Vancouver, ISO und andere Zitierweisen

50

YONG, XIE, und HSU WEN-JING. „ALIGNED MULTITHREADED COMPUTATIONS AND THEIR SCHEDULING WITH PERFORMANCE GUARANTEES“. Parallel Processing Letters 13, Nr. 03 (September 2003): 353–64. http://dx.doi.org/10.1142/s0129626403001331.

Der volle Inhalt der Quelle

Annotation:

This paper considers the problem of scheduling dynamic parallel computations to achieve linear speedup without using significantly more space per processor than that required for a single processor execution. Earlier research in the Cilk project proposed the "strict" computational model, in which every dependency goes from a thread x only to one of x's ancestor threads, and guaranteed both linear speedup and linear expansion of space. However, Cilk threads are stateless, and the task graph that Cilk language expresses is series-parallel graph, which is a proper subset of arbitrary task graph. Moreover, Cilk does not support applications with pipelining. We propose the "aligned" multithreaded computational model, which extends the "strict" computational model in Cilk. In the aligned multithreaded computational model, dependencies can go from arbitrary thread x not only to x's ancestor threads, but also to x's younger brother threads, that are spawned by x's parent thread but after x. We use the same measures of time and space as those used in Cilk: T1 is the time required for executing the computation on 1 processor, T∞ is the time required by an infinite number of processors, and S1 is the space required to execute the computation on 1 processor. We show that for any aligned computation, there exists an execution schedule that achieves both efficient time and efficient space. Specifically, we show that for an execution of any aligned multithreaded computation on P processors, the time required is bounded by O(T1/P + T∞), and the space required can be loosely bounded by O(λ·S1P), where λ is the maximum number of younger brother threads that have the same parent thread and can be blocked during execution. If we assume that λ is a constant, and the space requirements for elder and younger brother threads are the same, then the space required would be bounded by O(S1P). Based on the aligned multithreaded computational model, we show that the aligned multithreaded computational model supports pipelined applications. Furthermore, we propose a multithreaded programming language and show that it can express arbitrary task graph.

APA, Harvard, Vancouver, ISO und andere Zitierweisen

Zeitschriftenartikel zum Thema „Multithreaded application“

Geben Sie eine Quelle nach APA, MLA, Chicago, Harvard und anderen Zitierweisen an