Concurrency Challenges and Optimization Strategies in MultiCore Architectures
DOI:
https://doi.org/10.63282/3050-9246.IJETCSIT-V3I2P102Keywords:
Concurrency, multi-core processors, lock-free algorithms, transactional memory, workload balancing, parallel algorithms, cache optimization, hybrid concurrency control, dynamic workload balancing, hardware supportAbstract
Multi-core architectures have become the cornerstone of modern computing, offering significant performance improvements through parallel processing. However, these benefits come with substantial challenges, particularly in managing concurrency. This paper explores the key challenges in concurrent programming on multi-core systems and presents a comprehensive overview of optimization strategies. We delve into issues such as race conditions, deadlocks, and false sharing, and discuss advanced techniques like lock-free algorithms, transactional memory, and workload balancing. The paper also includes empirical evaluations and case studies to illustrate the effectiveness of these strategies. Finally, we provide a comparative analysis of different optimization techniques and offer recommendations for future research
Downloads
References
[1] Adedoyin, A. A., Negre, C. F. A., Mohd-Yusof, J., Bock, N., Osei-Kuffuor, D., Fattebert, J.-L., Wall, M. E., Niklasson, A. M.N., & Mniszewski, S. M. (2021). Performance optimizations of recursive electronic structure solvers targeting multi-core architectures. arXiv preprint arXiv:2102.08505. https://arxiv.org/abs/2102.08505
[2] Borkar, S., & Chien, A. A. (2011). The future of microprocessors. Communications of the ACM, 54(5), 67–77. https://doi.org/10.1145/1941487.1941507
[3] Boyd-Wickizer, S., Chen, H., Chen, R., Mao, Y., Kaashoek, M. F., Morris, R., Pesterev, A., Stein, L., Wu, M., Dai, Y., Zhang, Y., & others. (2010). Corey: An operating system for many cores. In Proceedings of the 8th USENIX conference on Operating systems design and implementation (pp. 43–57). USENIX Association.
[4] Cantini, R., Marozzo, F., Orsino, A., Talia, D., Trunfio, P., Badia, R. M., Ejarque, J., & Vázquez, F. (2022). Block size estimation for data partitioning in HPC applications using machine learning techniques. arXiv preprint arXiv:2211.10819. https://arxiv.org/abs/2211.10819
[5] Chandra, R., Menon, R., Dagum, L., Kohr, D., Maydan, D., & McDonald, J. (2001). Parallel programming in OpenMP. Morgan Kaufmann.
[6] Fatourou, P., Kallimanis, N. D., Kanellou, E., Makridakis, O., & Symeonidou, C. (2024). Efficient distributed data structures for future many-core architectures. arXiv preprint arXiv:2404.05515. https://arxiv.org/abs/2404.05515
[7] GeeksforGeeks. (n.d.). Challenges in programming for multicore systems. Retrieved from https://www.geeksforgeeks.org/challanges-in-programming-for-multicore-system/
[8] Gustafson, J. L. (1988). Reevaluating Amdahl's law. Communications of the ACM, 31(5), 532–533. https://doi.org/10.1145/42411.42415
[9] Herlihy, M., & Shavit, N. (2012). The art of multiprocessor programming (Revised Reprint). Morgan Kaufmann.
[10] Iorga, D., Sorensen, T., & Donaldson, A. F. (2018). Do your cores play nicely? A portable framework for multi-core interference tuning and analysis. arXiv preprint arXiv:1809.05197. https://arxiv.org/abs/1809.05197
[11] Juyal, C., Kulkarni, S., Kumari, S., Peri, S., & Somani, A. (2019). Achieving starvation-freedom with greater concurrency in multi-version object-based transactional memory systems. arXiv preprint arXiv:1904.03700. https://arxiv.org/abs/1904.03700
[12] Kirk, D. B., & Hwu, W.-M. W. (2016). Programming massively parallel processors: A hands-on approach (3rd ed.). Morgan Kaufmann.
[13] Lee, E. A. (2006). The problem with threads. Computer, 39(5), 33–42. https://doi.org/10.1109/MC.2006.180
[14] McCool, M., Reinders, J., & Robison, A. (2012). Structured parallel programming: Patterns for efficient computation. Morgan Kaufmann.
[15] McKenney, P. E. (2011). Is parallel programming hard, and, if so, what can you do about it? Linux Technology Center, IBM Beaverton.
[16] Sutter, H. (2005). The free lunch is over: A fundamental turn toward concurrency in software. Dr. Dobb's Journal, 30(3), 202–210.
[17] Tanenbaum, A. S., & Bos, H. (2014). Modern operating systems (4th ed.). Pearson.
[18] Williams, S., Waterman, A., & Patterson, D. (2009). Roofline: An insightful visual performance model for multicore architectures. Communications of the ACM, 52(4), 65–76. https://doi.org/10.1145/1498765.1498785
[19] Zhang, Y., Chen, X., & Shen, K. (2010). NUMA-aware thread scheduling: Case study on OpenSolaris and Linux. In USENIX Annual Technical Conference (pp.19–19).
[20] Zhuravlev, S., Blagodurov, S., & Fedorova, A. (2010). Addressing shared resource contention in multicore processors via scheduling. ACM SIGARCH Computer Architecture News, 38(1), 129–142. https://doi.org/10.1145/1735970.1736013
