The Experts below are selected from a list of 1701 Experts worldwide ranked by ideXlab platform

Mark Moir - One of the best experts on this subject based on the ideXlab platform.

Jaejin Lee - One of the best experts on this subject based on the ideXlab platform.

  • sfmalloc a lock free and mostly synchronization free dynamic Memory Allocator for manycores
    International Conference on Parallel Architectures and Compilation Techniques, 2011
    Co-Authors: Sangmin Seo, Junghyun Kim, Jaejin Lee
    Abstract:

    As parallel programming becomes the mainstream due to multicore processors, dynamic Memory Allocators used in C and C++ can suppress the performance of multi-threaded applications if they are not scalable. In this paper, we present a new dynamic Memory Allocator for multi-threaded applications. The Allocator never uses any synchronization for common cases. It uses only lock-free synchronization mechanisms for uncommon cases. Each thread owns a private heap and handles Memory requests on the heap. Our Allocator is completely synchronization-free when a thread allocates a Memory block and deal locates it by itself. Synchronization-free means that threads do not communicate with each other at all. On the other hand, if a thread allocates a block and another thread frees it, we use a lock-free stack to atomically add it to the owner thread's heap to avoid the Memory blowup problem. Furthermore, our Allocator exploits various Memory block caching mechanisms to reduce the latency of Memory management. Freed blocks or intermediate Memory chunks are cached hierarchically in each thread's heap and they are used for future Memory allocation. We compare the performance and scalability of our Allocator to those of well-known existing multi-threaded Memory Allocators using eight benchmarks. Experimental results on a 48-core AMD system show that our approach achieves better performance than other Allocators for all benchmarks and is highly scalable with a large number of threads.

  • PACT - SFMalloc: A Lock-Free and Mostly Synchronization-Free Dynamic Memory Allocator for Manycores
    2011 International Conference on Parallel Architectures and Compilation Techniques, 2011
    Co-Authors: Sangmin Seo, Junghyun Kim, Jaejin Lee
    Abstract:

    As parallel programming becomes the mainstream due to multicore processors, dynamic Memory Allocators used in C and C++ can suppress the performance of multi-threaded applications if they are not scalable. In this paper, we present a new dynamic Memory Allocator for multi-threaded applications. The Allocator never uses any synchronization for common cases. It uses only lock-free synchronization mechanisms for uncommon cases. Each thread owns a private heap and handles Memory requests on the heap. Our Allocator is completely synchronization-free when a thread allocates a Memory block and deal locates it by itself. Synchronization-free means that threads do not communicate with each other at all. On the other hand, if a thread allocates a block and another thread frees it, we use a lock-free stack to atomically add it to the owner thread's heap to avoid the Memory blowup problem. Furthermore, our Allocator exploits various Memory block caching mechanisms to reduce the latency of Memory management. Freed blocks or intermediate Memory chunks are cached hierarchically in each thread's heap and they are used for future Memory allocation. We compare the performance and scalability of our Allocator to those of well-known existing multi-threaded Memory Allocators using eight benchmarks. Experimental results on a 48-core AMD system show that our approach achieves better performance than other Allocators for all benchmarks and is highly scalable with a large number of threads.

Maurice Herlihy - One of the best experts on this subject based on the ideXlab platform.

Sangmin Seo - One of the best experts on this subject based on the ideXlab platform.

  • sfmalloc a lock free and mostly synchronization free dynamic Memory Allocator for manycores
    International Conference on Parallel Architectures and Compilation Techniques, 2011
    Co-Authors: Sangmin Seo, Junghyun Kim, Jaejin Lee
    Abstract:

    As parallel programming becomes the mainstream due to multicore processors, dynamic Memory Allocators used in C and C++ can suppress the performance of multi-threaded applications if they are not scalable. In this paper, we present a new dynamic Memory Allocator for multi-threaded applications. The Allocator never uses any synchronization for common cases. It uses only lock-free synchronization mechanisms for uncommon cases. Each thread owns a private heap and handles Memory requests on the heap. Our Allocator is completely synchronization-free when a thread allocates a Memory block and deal locates it by itself. Synchronization-free means that threads do not communicate with each other at all. On the other hand, if a thread allocates a block and another thread frees it, we use a lock-free stack to atomically add it to the owner thread's heap to avoid the Memory blowup problem. Furthermore, our Allocator exploits various Memory block caching mechanisms to reduce the latency of Memory management. Freed blocks or intermediate Memory chunks are cached hierarchically in each thread's heap and they are used for future Memory allocation. We compare the performance and scalability of our Allocator to those of well-known existing multi-threaded Memory Allocators using eight benchmarks. Experimental results on a 48-core AMD system show that our approach achieves better performance than other Allocators for all benchmarks and is highly scalable with a large number of threads.

  • PACT - SFMalloc: A Lock-Free and Mostly Synchronization-Free Dynamic Memory Allocator for Manycores
    2011 International Conference on Parallel Architectures and Compilation Techniques, 2011
    Co-Authors: Sangmin Seo, Junghyun Kim, Jaejin Lee
    Abstract:

    As parallel programming becomes the mainstream due to multicore processors, dynamic Memory Allocators used in C and C++ can suppress the performance of multi-threaded applications if they are not scalable. In this paper, we present a new dynamic Memory Allocator for multi-threaded applications. The Allocator never uses any synchronization for common cases. It uses only lock-free synchronization mechanisms for uncommon cases. Each thread owns a private heap and handles Memory requests on the heap. Our Allocator is completely synchronization-free when a thread allocates a Memory block and deal locates it by itself. Synchronization-free means that threads do not communicate with each other at all. On the other hand, if a thread allocates a block and another thread frees it, we use a lock-free stack to atomically add it to the owner thread's heap to avoid the Memory blowup problem. Furthermore, our Allocator exploits various Memory block caching mechanisms to reduce the latency of Memory management. Freed blocks or intermediate Memory chunks are cached hierarchically in each thread's heap and they are used for future Memory allocation. We compare the performance and scalability of our Allocator to those of well-known existing multi-threaded Memory Allocators using eight benchmarks. Experimental results on a 48-core AMD system show that our approach achieves better performance than other Allocators for all benchmarks and is highly scalable with a large number of threads.

Jong Woo Lee - One of the best experts on this subject based on the ideXlab platform.

  • object size and call site tracing based shared Memory Allocator for false sharing reduction in dsm systems
    Journal of Digital Contents Society, 2008
    Co-Authors: Jong Woo Lee, Youngho Park, Yongik Yoon
    Abstract:

    False sharing is a result of co-location of unrelated data in the same unit of Memory coherency, and is one source of unnecessary overhead being of no help to keep the Memory coherency in multiprocessor systems. Moreover, the damage caused by false sharing becomes large in proportion to the granularity of Memory coherency. To reduce false sharing in page-based DSM systems, it is necessary to allocate unrelated data objects that have different access patterns into the separate shared pages. In this paper we propose sized and call-site tracing-based shared Memory Allocator, shortly SCSTAllocator. SCSTAllocator places each data object requested from the different call-sites into the separate shared pages, and at the same time places each data object that has different size into different shared pages. Consequently data objects that have the different call-site and different object size prohibited from being allocated to the same shared page. Our observations show that our SCSTAllocator outperforms the existing dynamic shared Memory Allocators. By combining the two existing allocation technique, we can reduce a considerable amount of false sharing misses.

  • scstAllocator sized and call site tracing based shared Memory Allocator for false sharing reduction in page based dsm systems
    Intelligent Data Engineering and Automated Learning, 2007
    Co-Authors: Jong Woo Lee, Youngho Park, Yongik Yoon
    Abstract:

    False sharing is a result of co-location of unrelated data in the same unit of Memory coherency, and is one source of unnecessary overhead being of no help to keep the Memory coherency in multiprocessor systems. Moreover, the damage caused by false sharing becomes large in proportion to the granularity of Memory coherency. To reduce false sharing in page-based DSM systems, it is necessary to allocate unrelated data objects that have different access patterns into the separate shared pages. In this paper we propose sized and call-site tracing-based shared Memory Allocator, shortly SCSTAllocator. SCSTAllocator expects that the data objects requested from the different callsites may have different access patterns in the future. So SCSTAllocator places each data object requested from the different call-sites into the separate shared pages, and consequently data objects that have the same call-site are likely to get together into the same shared pages. At the same time SCSTAllocator places each data object that has different size into different shared pages to prohibit the different-sized objects from being allocated to the same shared page. We use execution-driven simulation of real parallel applications to evaluate the effectiveness of our SCSTAllocator. Our observations show that our SCSTAllocator outperforms the existing dynamic shared Memory Allocators. By combining the two existing allocation technique, we can reduce a considerable amount of false sharing misses.

  • CSTAllocator : Call-site tracing based shared Memory Allocator for false sharing reduction in page-based DSM systems
    Lecture Notes in Computer Science, 2006
    Co-Authors: Jong Woo Lee, Sung-dong Kim, Jae Won Lee, Jangmin O
    Abstract:

    False sharing is a result of co-location of unrelated data in the same unit of Memory coherency, and is one source of unnecessary overhead being of no help to keep the Memory coherency in multiprocessor systems. Moreover, the damage caused by false sharing becomes large in proportion to the granularity of Memory coherency. To reduce false sharing in page-based DSM systems, it is necessary to allocate unrelated data objects that have different access patterns into the separate shared pages. In this paper we propose call-site tracing-based shared Memory Allocator, shortly CSTAllocator. CSTAllocator expects that the data objects requested from the different call-sites may have different access patterns in the future. So CSTAllocator places each data object requested from the different call-sites into the separate shared pages, and consequently data objects that have the same call-site are likely to get together into the same shared pages. We use execution-driven simulation of real parallel applications to evaluate the effectiveness of our CSTAllocator. Our observations show that our CSTAllocator outperforms the existing dynamic shared Memory Allocator.

  • HPCC - CSTAllocator: call-site tracing based shared Memory Allocator for false sharing reduction in page-based DSM systems
    High Performance Computing and Communications, 2006
    Co-Authors: Jong Woo Lee, Sung-dong Kim, Jae Won Lee, Jangmin O
    Abstract:

    False sharing is a result of co-location of unrelated data in the same unit of Memory coherency, and is one source of unnecessary overhead being of no help to keep the Memory coherency in multiprocessor systems. Moreover, the damage caused by false sharing becomes large in proportion to the granularity of Memory coherency. To reduce false sharing in page-based DSM systems, it is necessary to allocate unrelated data objects that have different access patterns into the separate shared pages. In this paper we propose call-site tracing-based shared Memory Allocator, shortly CSTAllocator. CSTAllocator expects that the data objects requested from the different call-sites may have different access patterns in the future. So CSTAllocator places each data object requested from the different call-sites into the separate shared pages, and consequently data objects that have the same call-site are likely to get together into the same shared pages. We use execution-driven simulation of real parallel applications to evaluate the effectiveness of our CSTAllocator. Our observations show that our CSTAllocator outperforms the existing dynamic shared Memory Allocator.

  • Call-Site Tracing-based Shared Memory Allocator for False Sharing Reduction in DSM Systems
    Journal of KIISE:Computer Systems and Theory, 2005
    Co-Authors: Jong Woo Lee
    Abstract:

    False sharing is a result of co-location of unrelated data in the same unit of Memory coherency, and is one source of unnecessary overhead being of no help to keep the Memory coherency in multiprocessor systems. Moreover. the damage caused by false sharing becomes large in proportion to the granularity of Memory coherency. To reduce false sharing in a page-based DSM system, it is necessary to allocate unrelated data objects that have different access patterns into the separate shared pages. In this paper we propose call-site tracing-based shared Memory Allocator. shortly CSTAllocator. CSTAllocator expects that the data objects requested from the different call-sites may have different access patterns in the future. So CSTailocator places each data object requested from the different call-sites into the separate shared pages, and consequently data objects that have the same call-site are likely to get together into the same shared pages. We use execution-driven simulation of real parallel applications to evaluate the effectiveness of our CSTAllocator. Our observations show that by using CSTAllocator a considerable amount of false sharing misses can be additionally reduced in comparison with the existing techniques.