Linearity analysis of concurrent logic programs

    Research output: Contribution to journalArticle

    Abstract

    Automatic memory management and the hiding of the notion of pointers are the prominent features of symbolic processing languages. They make programming easy and guarantee the safety of memory references. For the memory management of linked data structures, copying garbage collection is most widely used because of its simplicity and desirable properties. However, if certain properties about runtime storage allocation and the behavior of pointers can be obtaind by static analysis, a compiler may be able to generate object code closer to that of procedural programs. In the fields of parallel, distributed and real-time computation, it is highly desirable to be able to identify data structures in a program that can be managed without using garbage collection. To this end, this paper proposes a framework of linearity analysis for a concurrent logic language Moded Flat GHC, and proves its basic property. The purpose of linearity analysis is to distinguish between fragments of data structures that may be referenced by two or more pointers and those that cannot be referenced by two or more pointers. Data structures with only one reader are amenable to compile-time garbage collection or local reuse. The proposed framework of linearity analysis is constraint-based and involves both equality and implicational constraints. It has been implemented as part of klint v2, a static analyzer for KL1 programs.

    Original languageEnglish
    Pages (from-to)177
    Number of pages1
    JournalElectronic Notes in Theoretical Computer Science
    Volume30
    Issue number2
    DOIs
    Publication statusPublished - 2000

    Fingerprint

    Logic Programs
    Linearity
    Garbage Collection
    Data structures
    Concurrent
    Data Structures
    Memory Management
    Data storage equipment
    Copying
    Linked Data
    Static analysis
    Static Analysis
    Computer programming
    Compiler
    Reuse
    Simplicity
    Equality
    Fragment
    Programming
    Safety

    ASJC Scopus subject areas

    • Computer Science (miscellaneous)

    Cite this

    Linearity analysis of concurrent logic programs. / Ueda, Kazunori.

    In: Electronic Notes in Theoretical Computer Science, Vol. 30, No. 2, 2000, p. 177.

    Research output: Contribution to journalArticle

    @article{52d76f1a3aaf4004b7199eb0ad53e908,
    title = "Linearity analysis of concurrent logic programs",
    abstract = "Automatic memory management and the hiding of the notion of pointers are the prominent features of symbolic processing languages. They make programming easy and guarantee the safety of memory references. For the memory management of linked data structures, copying garbage collection is most widely used because of its simplicity and desirable properties. However, if certain properties about runtime storage allocation and the behavior of pointers can be obtaind by static analysis, a compiler may be able to generate object code closer to that of procedural programs. In the fields of parallel, distributed and real-time computation, it is highly desirable to be able to identify data structures in a program that can be managed without using garbage collection. To this end, this paper proposes a framework of linearity analysis for a concurrent logic language Moded Flat GHC, and proves its basic property. The purpose of linearity analysis is to distinguish between fragments of data structures that may be referenced by two or more pointers and those that cannot be referenced by two or more pointers. Data structures with only one reader are amenable to compile-time garbage collection or local reuse. The proposed framework of linearity analysis is constraint-based and involves both equality and implicational constraints. It has been implemented as part of klint v2, a static analyzer for KL1 programs.",
    author = "Kazunori Ueda",
    year = "2000",
    doi = "10.1016/S1571-0661(05)80638-3",
    language = "English",
    volume = "30",
    pages = "177",
    journal = "Electronic Notes in Theoretical Computer Science",
    issn = "1571-0661",
    publisher = "Elsevier",
    number = "2",

    }

    TY - JOUR

    T1 - Linearity analysis of concurrent logic programs

    AU - Ueda, Kazunori

    PY - 2000

    Y1 - 2000

    N2 - Automatic memory management and the hiding of the notion of pointers are the prominent features of symbolic processing languages. They make programming easy and guarantee the safety of memory references. For the memory management of linked data structures, copying garbage collection is most widely used because of its simplicity and desirable properties. However, if certain properties about runtime storage allocation and the behavior of pointers can be obtaind by static analysis, a compiler may be able to generate object code closer to that of procedural programs. In the fields of parallel, distributed and real-time computation, it is highly desirable to be able to identify data structures in a program that can be managed without using garbage collection. To this end, this paper proposes a framework of linearity analysis for a concurrent logic language Moded Flat GHC, and proves its basic property. The purpose of linearity analysis is to distinguish between fragments of data structures that may be referenced by two or more pointers and those that cannot be referenced by two or more pointers. Data structures with only one reader are amenable to compile-time garbage collection or local reuse. The proposed framework of linearity analysis is constraint-based and involves both equality and implicational constraints. It has been implemented as part of klint v2, a static analyzer for KL1 programs.

    AB - Automatic memory management and the hiding of the notion of pointers are the prominent features of symbolic processing languages. They make programming easy and guarantee the safety of memory references. For the memory management of linked data structures, copying garbage collection is most widely used because of its simplicity and desirable properties. However, if certain properties about runtime storage allocation and the behavior of pointers can be obtaind by static analysis, a compiler may be able to generate object code closer to that of procedural programs. In the fields of parallel, distributed and real-time computation, it is highly desirable to be able to identify data structures in a program that can be managed without using garbage collection. To this end, this paper proposes a framework of linearity analysis for a concurrent logic language Moded Flat GHC, and proves its basic property. The purpose of linearity analysis is to distinguish between fragments of data structures that may be referenced by two or more pointers and those that cannot be referenced by two or more pointers. Data structures with only one reader are amenable to compile-time garbage collection or local reuse. The proposed framework of linearity analysis is constraint-based and involves both equality and implicational constraints. It has been implemented as part of klint v2, a static analyzer for KL1 programs.

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

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

    U2 - 10.1016/S1571-0661(05)80638-3

    DO - 10.1016/S1571-0661(05)80638-3

    M3 - Article

    AN - SCOPUS:19144365428

    VL - 30

    SP - 177

    JO - Electronic Notes in Theoretical Computer Science

    JF - Electronic Notes in Theoretical Computer Science

    SN - 1571-0661

    IS - 2

    ER -