Extracting permission-based specifications from a sequential Java program

Ayesha Sadiq, Yuan-Fang Li, Sea Ling, Ijaz Ahmad

    Research output: Chapter in Book/Report/Conference proceedingConference PaperResearchpeer-review

    Abstract

    It is expected that muti-core systems will become the dominant computing platform in the next few years. However, the current programming models (such as Java, .Net etc.) do not scale well to exploit the computing power of such multi-core systems. In primitive programming paradigms there exist implicit dependencies between code and program states, and compilers cannot exploit the potential concurrency present in the program unless the programmer introduces concurrency manually using multi-threading, which is prone to errors such as race conditions and deadlocks. The goal of this research is to help programmers achieve concurrency without mastering the intricacies of this domain. We propose a formal technique and a high-level algorithm to extract implicit dependencies from a sequential Java program in the form of access permission rights. The proposed technique performs static analysis of the source code on a modular basis. The inferred permissions can potentially be used by runtime engines such as Java Virtual Machine (JVM) to automatically parallelize sequential programs on multi-core systems and to reason about concurrency.
    LanguageEnglish
    Title of host publication21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016)
    Subtitle of host publicationDubai, United Arab Emirates, 6-8 November 2016, Proceedings
    EditorsHai Wang, Mounir Mokhtari
    Place of PublicationLos Alamitos, CA
    PublisherIEEE Computer Society
    Pages215-218
    Number of pages4
    ISBN (Electronic)9781509055272
    ISBN (Print)9781509055265
    DOIs
    Publication statusPublished - 12 Jan 2017
    EventIEEE International Conference on Engineering of Complex Computer Systems 2016 - Dubai, United Arab Emirates
    Duration: 6 Nov 20168 Nov 2016
    Conference number: 21st

    Conference

    ConferenceIEEE International Conference on Engineering of Complex Computer Systems 2016
    Abbreviated titleICECCS 2016
    CountryUnited Arab Emirates
    CityDubai
    Period6/11/168/11/16

    Keywords

    • Access permissions
    • Static analysis
    • Concurrency
    • Permission inference

    Cite this

    Sadiq, A., Li, Y-F., Ling, S., & Ahmad, I. (2017). Extracting permission-based specifications from a sequential Java program. In H. Wang, & M. Mokhtari (Eds.), 21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016): Dubai, United Arab Emirates, 6-8 November 2016, Proceedings (pp. 215-218). [7816590] Los Alamitos, CA: IEEE Computer Society. https://doi.org/10.1109/ICECCS.2016.037
    Sadiq, Ayesha ; Li, Yuan-Fang ; Ling, Sea ; Ahmad, Ijaz. / Extracting permission-based specifications from a sequential Java program. 21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016): Dubai, United Arab Emirates, 6-8 November 2016, Proceedings. editor / Hai Wang ; Mounir Mokhtari. Los Alamitos, CA : IEEE Computer Society, 2017. pp. 215-218
    @inproceedings{5831f7b5933c4b769ffe3073fdececcb,
    title = "Extracting permission-based specifications from a sequential Java program",
    abstract = "It is expected that muti-core systems will become the dominant computing platform in the next few years. However, the current programming models (such as Java, .Net etc.) do not scale well to exploit the computing power of such multi-core systems. In primitive programming paradigms there exist implicit dependencies between code and program states, and compilers cannot exploit the potential concurrency present in the program unless the programmer introduces concurrency manually using multi-threading, which is prone to errors such as race conditions and deadlocks. The goal of this research is to help programmers achieve concurrency without mastering the intricacies of this domain. We propose a formal technique and a high-level algorithm to extract implicit dependencies from a sequential Java program in the form of access permission rights. The proposed technique performs static analysis of the source code on a modular basis. The inferred permissions can potentially be used by runtime engines such as Java Virtual Machine (JVM) to automatically parallelize sequential programs on multi-core systems and to reason about concurrency.",
    keywords = "Access permissions, Static analysis, Concurrency, Permission inference",
    author = "Ayesha Sadiq and Yuan-Fang Li and Sea Ling and Ijaz Ahmad",
    year = "2017",
    month = "1",
    day = "12",
    doi = "10.1109/ICECCS.2016.037",
    language = "English",
    isbn = "9781509055265",
    pages = "215--218",
    editor = "Hai Wang and Mounir Mokhtari",
    booktitle = "21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016)",
    publisher = "IEEE Computer Society",
    address = "United States",

    }

    Sadiq, A, Li, Y-F, Ling, S & Ahmad, I 2017, Extracting permission-based specifications from a sequential Java program. in H Wang & M Mokhtari (eds), 21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016): Dubai, United Arab Emirates, 6-8 November 2016, Proceedings., 7816590, IEEE Computer Society, Los Alamitos, CA, pp. 215-218, IEEE International Conference on Engineering of Complex Computer Systems 2016, Dubai, United Arab Emirates, 6/11/16. https://doi.org/10.1109/ICECCS.2016.037

    Extracting permission-based specifications from a sequential Java program. / Sadiq, Ayesha; Li, Yuan-Fang; Ling, Sea; Ahmad, Ijaz.

    21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016): Dubai, United Arab Emirates, 6-8 November 2016, Proceedings. ed. / Hai Wang; Mounir Mokhtari. Los Alamitos, CA : IEEE Computer Society, 2017. p. 215-218 7816590.

    Research output: Chapter in Book/Report/Conference proceedingConference PaperResearchpeer-review

    TY - GEN

    T1 - Extracting permission-based specifications from a sequential Java program

    AU - Sadiq, Ayesha

    AU - Li, Yuan-Fang

    AU - Ling, Sea

    AU - Ahmad, Ijaz

    PY - 2017/1/12

    Y1 - 2017/1/12

    N2 - It is expected that muti-core systems will become the dominant computing platform in the next few years. However, the current programming models (such as Java, .Net etc.) do not scale well to exploit the computing power of such multi-core systems. In primitive programming paradigms there exist implicit dependencies between code and program states, and compilers cannot exploit the potential concurrency present in the program unless the programmer introduces concurrency manually using multi-threading, which is prone to errors such as race conditions and deadlocks. The goal of this research is to help programmers achieve concurrency without mastering the intricacies of this domain. We propose a formal technique and a high-level algorithm to extract implicit dependencies from a sequential Java program in the form of access permission rights. The proposed technique performs static analysis of the source code on a modular basis. The inferred permissions can potentially be used by runtime engines such as Java Virtual Machine (JVM) to automatically parallelize sequential programs on multi-core systems and to reason about concurrency.

    AB - It is expected that muti-core systems will become the dominant computing platform in the next few years. However, the current programming models (such as Java, .Net etc.) do not scale well to exploit the computing power of such multi-core systems. In primitive programming paradigms there exist implicit dependencies between code and program states, and compilers cannot exploit the potential concurrency present in the program unless the programmer introduces concurrency manually using multi-threading, which is prone to errors such as race conditions and deadlocks. The goal of this research is to help programmers achieve concurrency without mastering the intricacies of this domain. We propose a formal technique and a high-level algorithm to extract implicit dependencies from a sequential Java program in the form of access permission rights. The proposed technique performs static analysis of the source code on a modular basis. The inferred permissions can potentially be used by runtime engines such as Java Virtual Machine (JVM) to automatically parallelize sequential programs on multi-core systems and to reason about concurrency.

    KW - Access permissions

    KW - Static analysis

    KW - Concurrency

    KW - Permission inference

    UR - http://www.scopus.com/inward/record.url?scp=85012083477&partnerID=8YFLogxK

    U2 - 10.1109/ICECCS.2016.037

    DO - 10.1109/ICECCS.2016.037

    M3 - Conference Paper

    SN - 9781509055265

    SP - 215

    EP - 218

    BT - 21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016)

    A2 - Wang, Hai

    A2 - Mokhtari, Mounir

    PB - IEEE Computer Society

    CY - Los Alamitos, CA

    ER -

    Sadiq A, Li Y-F, Ling S, Ahmad I. Extracting permission-based specifications from a sequential Java program. In Wang H, Mokhtari M, editors, 21st International Conference on Engineering of Complex Computer Systems (ICECCS 2016): Dubai, United Arab Emirates, 6-8 November 2016, Proceedings. Los Alamitos, CA: IEEE Computer Society. 2017. p. 215-218. 7816590 https://doi.org/10.1109/ICECCS.2016.037