The Experts below are selected from a list of 80817 Experts worldwide ranked by ideXlab platform
Dimitrios S Nikolopoulos - One of the best experts on this subject based on the ideXlab platform.
-
bddt block level dynamic dependence analysis for task based parallelism
APPT 2013 Revised Selected Papers of the 10th International Symposium on Advanced Parallel Processing Technologies - Volume 8299, 2013Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, Dimitrios S NikolopoulosAbstract:We present BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range, multidimensional array tile or dynamic region. BDDT uses a block-based dependence analysis with arbitrary granularity. The analysis is applicable to existing C programs without having to restructure object or array allocation, and provides flexibility in array layouts and tile dimensions. We evaluate BDDT using a representative set of benchmarks, and we compare it to SMPSs the equivalent runtime system in StarSs and OpenMP. BDDT performs comparable to or better than SMPSs and is able to cope with task granularity as much as one order of magnitude finer than SMPSs. Compared to OpenMP, BDDT performs up to 3.9× better for benchmarks that benefit from dynamic dependence analysis. BDDT provides additional data annotations to bypass dependence analysis. Using these annotations, BDDT outperforms OpenMP also in benchmarks where dependence analysis does not discover additional parallelism, thanks to a more efficient implementation of the runtime system.
-
bddt block level dynamic dependence analysisfor deterministic task based parallelism
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2012Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, John Kesapides, Dimitrios S NikolopoulosAbstract:Reasoning about synchronization, ordering and conflicting Memory accesses makes parallel programming difficult, error-prone and hard to test, debug and maintain. Task-parallel programming models such as OpenMP, Cilk and Sequoia offer a more structured way of expressing parallelism than threads, but still require the programmer to manually find and enforce any ordering or Memory dependencies among tasks. Programming models with implicit parallelism such as SvS, OoOJava, or StarSs lift this limitation by automatically inferring parallelism and dependencies, requiring the programmer to describe the Memory footprint of each task. Current limitations of these systems require the programmer to restrict task footprints into either whole and isolated program objects, one-dimensional array ranges, or static compile-time regions; all producing over-approximations and false dependencies that reduce the available parallelism in the program. This paper presents BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range or multidimensional array tile. BDDT uses a block-based dependence analysis with arbitrary granularity, making it easier to apply to
George Tzenakis - One of the best experts on this subject based on the ideXlab platform.
-
bddt block level dynamic dependence analysis for task based parallelism
APPT 2013 Revised Selected Papers of the 10th International Symposium on Advanced Parallel Processing Technologies - Volume 8299, 2013Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, Dimitrios S NikolopoulosAbstract:We present BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range, multidimensional array tile or dynamic region. BDDT uses a block-based dependence analysis with arbitrary granularity. The analysis is applicable to existing C programs without having to restructure object or array allocation, and provides flexibility in array layouts and tile dimensions. We evaluate BDDT using a representative set of benchmarks, and we compare it to SMPSs the equivalent runtime system in StarSs and OpenMP. BDDT performs comparable to or better than SMPSs and is able to cope with task granularity as much as one order of magnitude finer than SMPSs. Compared to OpenMP, BDDT performs up to 3.9× better for benchmarks that benefit from dynamic dependence analysis. BDDT provides additional data annotations to bypass dependence analysis. Using these annotations, BDDT outperforms OpenMP also in benchmarks where dependence analysis does not discover additional parallelism, thanks to a more efficient implementation of the runtime system.
-
bddt block level dynamic dependence analysisfor deterministic task based parallelism
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2012Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, John Kesapides, Dimitrios S NikolopoulosAbstract:Reasoning about synchronization, ordering and conflicting Memory accesses makes parallel programming difficult, error-prone and hard to test, debug and maintain. Task-parallel programming models such as OpenMP, Cilk and Sequoia offer a more structured way of expressing parallelism than threads, but still require the programmer to manually find and enforce any ordering or Memory dependencies among tasks. Programming models with implicit parallelism such as SvS, OoOJava, or StarSs lift this limitation by automatically inferring parallelism and dependencies, requiring the programmer to describe the Memory footprint of each task. Current limitations of these systems require the programmer to restrict task footprints into either whole and isolated program objects, one-dimensional array ranges, or static compile-time regions; all producing over-approximations and false dependencies that reduce the available parallelism in the program. This paper presents BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range or multidimensional array tile. BDDT uses a block-based dependence analysis with arbitrary granularity, making it easier to apply to
Yutaka Ishikawa - One of the best experts on this subject based on the ideXlab platform.
-
partially separated page tables for efficient operating system assisted hierarchical Memory management on heterogeneous architectures
IEEE ACM International Symposium Cluster Cloud and Grid Computing, 2013Co-Authors: Balazs Gerofi, Atsushi Hori, A Shimada, Yutaka IshikawaAbstract:Heterogeneous architectures, where a multicore processor is accompanied with a large number of simpler, but more power-efficient CPU cores optimized for parallel workloads, are receiving a lot of attention recently. At present, these co-processors, such as the Intel Xeon Phi product family, come with limited on-board Memory, which requires partitioning computational problems manually into pieces that can fit into the device's RAM, as well as efficiently overlapping computation and communication. In this paper we propose an application transparent, operating system (OS)assisted hierarchical Memory management system, where the OS orchestrates data movement between the host and the device and updates the process virtual Memory Address space accordingly. We identify the main scalability issues of frequent Address space changes, such as the increasing price of TLB invalidations with the growing number of CPU cores, and propose partially separated page tables with Address-range CPU masks to overcome the problem. With partially separated page tables each core maintains its own set of mappings of the computation area, enabling the OS to perform Address space updates in a scalable manner, and involve a particular CPU core in TLB invalidation only if it is absolutely necessary. Furthermore, we propose dedicated data movement cores in order to efficiently overlap computation and communication. We provide experimental results on stencil computation, a common HPCkernel, and show that OS assisted Memory management has the potential for scalable transparent data movement.
-
pin down cache a virtual Memory management technique for zero copy communication
Merged International Parallel Processing Symposium and Symposium on Parallel and Distributed Processing, 1998Co-Authors: Hiroshi Tezuka, Francis Ocarroll, Atsushi Hori, Yutaka IshikawaAbstract:The overhead of copying data through the central processor by a message passing protocol limits data transfer bandwidth. If the network interface directly transfers the user's Memory to the network by issuing DMA, such data copies may be eliminated. Since the DMA facility accesses the physical Memory Address space, user virtual Memory must be pinned down to a physical Memory location before the message is sent or received. If each message transfer involves pin-down and release kernel primitives, message transfer bandwidth will decrease since those primitives are quite expensive. The authors propose a zero copy message transfer with a pin-down cache technique which reuses the pinned-down area to decrease the number of calls to pin-down and release primitives. The proposed facility has been implemented in the PM low-level communication library on the RWC PC Cluster II, consisting of 64 Pentium Pro 200 MHz CPUs connected by a Myricom Myrinet network, and running NetBSD. The PM achieves 108.8 MBytes/sec for a 100% pin-down cache hit ratio and 78.7 MBytes/sec for all pin-down cache miss. The MPI library has been implemented on top of PM. According to the NAS parallel benchmarks result, an application is still better performance in case that cache miss ratio is very high.
Polyvios Pratikakis - One of the best experts on this subject based on the ideXlab platform.
-
bddt block level dynamic dependence analysis for task based parallelism
APPT 2013 Revised Selected Papers of the 10th International Symposium on Advanced Parallel Processing Technologies - Volume 8299, 2013Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, Dimitrios S NikolopoulosAbstract:We present BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range, multidimensional array tile or dynamic region. BDDT uses a block-based dependence analysis with arbitrary granularity. The analysis is applicable to existing C programs without having to restructure object or array allocation, and provides flexibility in array layouts and tile dimensions. We evaluate BDDT using a representative set of benchmarks, and we compare it to SMPSs the equivalent runtime system in StarSs and OpenMP. BDDT performs comparable to or better than SMPSs and is able to cope with task granularity as much as one order of magnitude finer than SMPSs. Compared to OpenMP, BDDT performs up to 3.9× better for benchmarks that benefit from dynamic dependence analysis. BDDT provides additional data annotations to bypass dependence analysis. Using these annotations, BDDT outperforms OpenMP also in benchmarks where dependence analysis does not discover additional parallelism, thanks to a more efficient implementation of the runtime system.
-
bddt block level dynamic dependence analysisfor deterministic task based parallelism
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2012Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, John Kesapides, Dimitrios S NikolopoulosAbstract:Reasoning about synchronization, ordering and conflicting Memory accesses makes parallel programming difficult, error-prone and hard to test, debug and maintain. Task-parallel programming models such as OpenMP, Cilk and Sequoia offer a more structured way of expressing parallelism than threads, but still require the programmer to manually find and enforce any ordering or Memory dependencies among tasks. Programming models with implicit parallelism such as SvS, OoOJava, or StarSs lift this limitation by automatically inferring parallelism and dependencies, requiring the programmer to describe the Memory footprint of each task. Current limitations of these systems require the programmer to restrict task footprints into either whole and isolated program objects, one-dimensional array ranges, or static compile-time regions; all producing over-approximations and false dependencies that reduce the available parallelism in the program. This paper presents BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range or multidimensional array tile. BDDT uses a block-based dependence analysis with arbitrary granularity, making it easier to apply to
Angelos Papatriantafyllou - One of the best experts on this subject based on the ideXlab platform.
-
bddt block level dynamic dependence analysis for task based parallelism
APPT 2013 Revised Selected Papers of the 10th International Symposium on Advanced Parallel Processing Technologies - Volume 8299, 2013Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, Dimitrios S NikolopoulosAbstract:We present BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range, multidimensional array tile or dynamic region. BDDT uses a block-based dependence analysis with arbitrary granularity. The analysis is applicable to existing C programs without having to restructure object or array allocation, and provides flexibility in array layouts and tile dimensions. We evaluate BDDT using a representative set of benchmarks, and we compare it to SMPSs the equivalent runtime system in StarSs and OpenMP. BDDT performs comparable to or better than SMPSs and is able to cope with task granularity as much as one order of magnitude finer than SMPSs. Compared to OpenMP, BDDT performs up to 3.9× better for benchmarks that benefit from dynamic dependence analysis. BDDT provides additional data annotations to bypass dependence analysis. Using these annotations, BDDT outperforms OpenMP also in benchmarks where dependence analysis does not discover additional parallelism, thanks to a more efficient implementation of the runtime system.
-
bddt block level dynamic dependence analysisfor deterministic task based parallelism
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2012Co-Authors: George Tzenakis, Polyvios Pratikakis, Angelos Papatriantafyllou, Hans Vandierendonck, John Kesapides, Dimitrios S NikolopoulosAbstract:Reasoning about synchronization, ordering and conflicting Memory accesses makes parallel programming difficult, error-prone and hard to test, debug and maintain. Task-parallel programming models such as OpenMP, Cilk and Sequoia offer a more structured way of expressing parallelism than threads, but still require the programmer to manually find and enforce any ordering or Memory dependencies among tasks. Programming models with implicit parallelism such as SvS, OoOJava, or StarSs lift this limitation by automatically inferring parallelism and dependencies, requiring the programmer to describe the Memory footprint of each task. Current limitations of these systems require the programmer to restrict task footprints into either whole and isolated program objects, one-dimensional array ranges, or static compile-time regions; all producing over-approximations and false dependencies that reduce the available parallelism in the program. This paper presents BDDT, a task-parallel runtime system that dynamically discovers and resolves dependencies among parallel tasks. BDDT allows the programmer to specify detailed task footprints on any Memory Address range or multidimensional array tile. BDDT uses a block-based dependence analysis with arbitrary granularity, making it easier to apply to