In this section, we discuss some of the remaining open problems and directions for further research on the mutual exclusion problem.
Only fetch&store is investigated in Chapter 4. Herlihy [27] has provided a
wait-free hierarchy that classifies synchronization primitives according to their power to solve consensus. A future direction is to provide a separation among all multi-processor synchronization primitives based on the space complexity of solutions to the mutual exclusion problem. Interestingly, compare&swap, which is considered to be powerful according to Herlihy’s wait-free hierarchy, is not a good choice to de-crease the space requirement. A recent paper of Fich et al. [21] shows that at least n shared variables are required to solve the n-process mutual exclusion problem if only conditional primitives, such as compare&swap, are available. Their result indicates an inherent difference between the two problems.
The algorithms proposed in Chapter 4 are optimal with respect to the number of shared variables. Future work is needed to establish the tight bound on the size of shared variables. Although each of the algorithms utilizes two shared variables, the total values taken on by the shared variables in the FCFS algorithm is larger than that in the 2-bounded-bypass algorithm. An interesting question is how large the two shared variables must be in order to guarantee bounded bypass or FCFS.
One disadvantage of Huang’s algorithm is that it uses two primitives, compare&swap and fetch&store, besides read/write. Since Cypher [15] showed that there is no constant time algorithm using conditional RMW primitives and read/write, a non-conditional RMW primitive is needed to implement an algorithm whose upper bound matches the lower bound in Chapter 5. An open question is whether such an algorithm is obtainable using only one non-conditional RMW primitive such as fetch&store in addition to read/write.
In addition, although Huang’s algorithm satisfies lockout-freedom and bounded bypass, it does not satisfy the FCFS property. Hence, the tight bound on the RMR time complexity for the FCFS mutual exclusion problem remains to be solved. The tight bound must be either three or four, because the MCS lock [37] satisfies the FCFS property and its RMR time complexity is four, and our lower bound of three also holds for the problem.
We focus only on DSM systems when studying on the RMR time complexity of the mutual exclusion problem. The lower bound proof herein is not applicable
to CC systems. Future work is needed to establish the exact lower bound in CC systems.
Bibliography
[1] ARM1136JF-S and ARM1136J-S Technical
Refer-ence Manual. ARM Inc., 2005. Available at
http://www.arm.com/documentation/ARMProcessor Cores/.
[2] J. H. Anderson and Y.-J. Kim. An improved lower bound for the time com-plexity of mutual exclusion. Distributed Computing, 15(4):221–253, December 2002.
[3] J. H. Anderson and Y.-J. Kim. Nonatomic mutual exclusion with local spinning.
In Proceedings of the 21st Annual ACM Symposium on Principles of Distributed Computing, pages 3–12, July 2002.
[4] J. H. Anderson and Y.-J. Kim. Local-spin mutual exclusion using fetch-and-φ primitives. In Proceedings of the 23rd IEEE International Conference on Distributed Computing Systems, pages 538–547, May 2003.
[5] J. H. Anderson, Y.-J. Kim, and T. Herman. Shared-memory mutual exclu-sion: major research trends since 1986. Distributed Computing, 16(2-3):75–110, September 2003.
[6] J. H. Anderson and M. Moir. Using local-spin k-exclusion algorithms to improve wait-free object implementations. Distributed Computing, 11(1):1–20, 1997.
[7] J. H. Anderson and J.-H. Yang. Time/contention trade-offs for multiprocessor synchronization. Information and Computation, 124(1):68–84, January 1996.
[8] T. E. Anderson. The performance of spin lock alternatives for shared-memory multiprocessors. IEEE Transactions on Parallel and Distributed Systems, 1(1):6–16, January 1990.
[9] J. E. Burns. Mutual exclusion with linear waiting using binary shared variables.
ACM SIGACT News, 10(2):42–47, 1978.
[10] J. E. Burns, P. Jackson, N. A. Lynch, M. J. Fischer, and G. L. Peterson. Data requirements for implementation of n-process mutual exclusion using a single shared variable. Journal of the ACM, 29(1):183–205, January 1982.
[11] J. E. Burns and N. A. Lynch. Bounds on shared memory for mutual exclusion.
Information and Computation, 107(2):171–184, December 1993.
[12] K. M. Chandy and J. Misra. How processes learn. Distributed Computing, 1:40–52, 1986.
[13] S.-H. Chen and T.-L Huang. A tight bound on time complexity of mutual exclusion. In Proceedings of the International Computer Symposium, pages 1352–1357, Taipei, Taiwan, December 2004.
[14] T. S. Craig. Queuing spin lock algorithms to support timing predictability. In Proceedings of the 14th IEEE Real-Time Systems Symposium, pages 148–157, December 1993.
[15] R. Cypher. The communication requirements of mutual exclusion. In Pro-ceedings of the Seventh Annual ACM Symposium on Parallel Algorithms and Architectures, pages 147–156, June 1995.
[16] R. Danek and V. Hadzilacos. Local-spin group mutual exclusion algorithms.
In Proceedings of the 18th International Symposium on Distributed Computing, October 2004.
[17] N. G. deBruijn. Additional comments on a problem in concurrent programming control. Communication of the ACM, 10(3):137–138, 1967.
[18] E. W. Dijkstra. Solution of a problem in concurrent programming control.
Communications of the ACM, 8(9):569, September 1965.
[19] C. Dwork, M. Herlihy, and O. Waarts. Contention in shared memory algorithms.
Journal of the ACM, 44(6):779–805, November 1997.
[20] M. A. Eisenberg and M. R. McGuire. Further comments on dijkstra’s concurrent programming control problem. Communication of the ACM, 15(11):999, 1972.
[21] F. Fich, D. Hendler, and N. Shavit. On the inherent weakness of conditional primitives. Distributed Computing, 18(4):267–277, March 2006.
[22] F. Fich, M. Herlihy, and N. Shavit. On the space complexity of randomized synchronization. Journal of the ACM, 45(5):843–862, September 1998.
[23] M. J. Fischer, N. A. Lynch, J. E. Burns, and A. Borodin. Distributed FIFO allocation of identical resources using small shared space. ACM Transactions on Programming Languages and Systems, 11(1):90–114, January 1989.
[24] S. S. Fu and N.-F. Tzeng. A circular list-based mutual exclusion scheme for large shared-memory multiprocessors. IEEE Transactions on Parallel and Distributed Systems, 8(6):628–639, June 1997.
[25] J. G. Ganssle. The Art of Programming Embedded Systems. Academic Press, 1991.
[26] G. Graunke and S. Thakkar. Synchronization algorithms for shared-memory multiprocessors. IEEE Computer, 23(6):60–69, June 1990.
[27] M. Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems, 13(1):124–149, January 1991.
[28] T.-L. Huang. Fast and fair mutual exclusion for shared memory systems. In Proceedings of the 19th IEEE International Conference on Distributed Comput-ing Systems, pages 224–231, June 1999.
[29] T.-L. Huang and J.-H. Lin. An assertional proof of a lock synchronization algorithm using fetch and store atomic instructions. In Proceedings of the 1994 International Conference on Parallel and Distributed Systems, pages 759–768.
IEEE, December 1994.
[30] T.-L. Huang and C.-H. Shann. A comment on “A circular list-based mutual exclusion scheme for large shared-memory multiprocessors”. IEEE Transactions on Parallel and Distributed Systems, 9(4):414–415, April 1998.
[31] P. Keane and M. Moir. A simple local-spin group mutual exclusion algorithm.
IEEE Transactions on Parallel and Distributed Systems, 12(7):673–685, July 2001.
[32] Y.-J. Kim and J. H. Anderson. A time complexity bound for adaptive mutual exclusion. In Proceedings of the 15th International Symposium on Distributed Computing, pages 1–15, October 2001.
[33] D. E. Knuth. Additional comments on a problem in concurrent programming control. Communication of the ACM, 9(5):321–322, 1966.
[34] L. Lamport. A new solution of Dijkstra’s concurrent programming problem.
Communication of the ACM, 17(8):453–455, August 1974.
[35] N. A. Lynch. Distributed Algorithms. Morgan Kaufmann, 1996.
[36] P. Magnusson, A. Landin, and E. Hagersten. Oueue locks on cache coherent multiprocessors. In Proceedings of the 8th International Symposium on Parallel Processing, pages 165–171. IEEE, April 1994.
[37] J. M. Mellor-Crummey and M. L. Scott. Algorithms for scalable synchronization on shared-memory multiprocessors. ACM Transactions on Computer Systems, 9(1):21–65, February 1991.
[38] G. L. Peterson. Myths about the mutual exclusion problem. Information Processing Letters, 12(3):115–116, June 1981.
[39] M. Raynal. Algorithms for Mutual Exclusion. The MIT Press, 1986.
[40] I. Rhee. Optimizing a FIFO, scalable spin lock using consistent memory. In Proceedings of the 17th IEEE Real-Time Systems Symposium, pages 106–114, December 1996.
[41] J.-H Yang and J. H. Anderson. A fast, scalable mutual exclusion algorithm.
Distributed Computing, 9(1):51–60, August 1995.
[42] K. M. Zuberi and K. G. Shin. An efficient semaphore implementation scheme for small-memory embedded systems. In Proceedings of the Third IEEE Real-Time Technology and Applications Symposium, pages 25–34, June 1997.
[43] K. M. Zuberi and K. G. Shin. EMERALDS: a small-memory real-time micro-kernel. IEEE Transactions on Software Engineering, 27(10):909–927, October 2001.