Browsing by Author "Landry, Kenneth D."

Now showing 1 - 8 of 8
  • Thumbnail Image
    Achieving Asynchronous Speedup While Preserving Synchronous Semantics: An Implementation of Instructional Footprinting in Linda
    Landry, Kenneth D.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1993)
    Linda is a coordination language designed to support process creation and inter-process communication within conventional computational languages. Although the Linda paradigm touts architectural and language independence, it often suffers performance penalties, particularly on local area network platforms. Instructional Footprinting is an optimization technique with the primary goal of enhancing the execution speed of Linda programs. The two main aspects of Instructional Footprinting are instructional decomposition and code motion. This paper addresses the semantic issues encountered when the Linda primitives, IN and RD, are decomposed and moved past other Linda operations. Formal semantics are given as well as results showing significant speedup (as high as 64%) when Instructional Footprinting is used.
  • Thumbnail Image
    Comparison of Unix Communication Facilities Used in Linda
    Schumann, Chuck; Landry, Kenneth D.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    This report presents the results of an investigative effort that focuses on a first step toward providing a distributed framework for Linda system processes. In particular, we discuss the restructuring of the kernel "process" to support Tuple Space access through UNIX socket calls, rather than through shared memory primitives based on semaphore usage. A description of the restructured system and the rationale for such restructuring is presented first. Most intriguing, however, are the latter sections that discuss the ramifications and insights gained from our particular approach to system redesign, i.e., the unnecessary serialization of Tuple Space access, redundant memory copies, being victimized by the UNIX scheduler.
  • Thumbnail Image
    A Distributed Parallel Processing Environment Based upon the Linda Paradigm: A Research Prospectus
    Landry, Kenneth D.; Cline, George E.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    As the computing capacity of the uniprocessor is being taxed, and the high cost of parallel and super-computers is still prevalent, alternative methods of achieving parallel performance at an economical price are desired. This proposed research effort offers one such alternative, focusing on the idle CPU cycles existing on local area networks. With the increase in the computing power of workstations and their declining costs, one can effectively transform the unused computing power attached to a local area network into a parallel processing environment. Effectively exploiting such an environment, however, requires a specification and operational framework that is portable, easy to use, and efficient. The environment is constructed around the Linda parallel programming paradigm which provides an effective parallel computational framework.
  • Thumbnail Image
    Evolutionary neural networks
    Landry, Kenneth D. (Virginia Polytechnic Institute and State University, 1988)
    To create neural networks that work, one needs to specify a structure and the interconnection weights between each pair of connected computing elements. The structure of a network can be selected by the designer depending on the application, although the selection of interconnection weights is a much larger problem. Algorithms have been developed to alter the weights slightly in order to produce the desired results. Learning algorithms such as Hebb's rule, the Delta rule and error propagation have been used, with success, to learn the appropriate weights. The major objection to this class of algorithms is that one cannot specify what is not desired in the network in addition to what is desired. An alternate method to learning the correct interconnection weights is to evolve a network in an environment that rewards "good” behavior and punishes "bad" behavior, This technique allows interesting networks to appear which otherwise may not be discovered by other methods of learning. In order to teach a network the correct weights, this approach simply needs a direction where an acceptable solution can be obtained rather than a complete answer to the problem.
  • Thumbnail Image
    Instructional Footprinting and Semantic Preservation in Linda
    Landry, Kenneth D.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1993)
    Linda is a coordination language designed to support process creation and inter-process communication within conventional computational languages. Although the Linda paradigm touts architectural and language independence, it often suffers performance penalties, particularly on local area network platforms. Instructional Footprinting is an optimization technique with the primary goal of enhancing the execution speed of Linda programs. The two main aspects of Instructional Footprinting are instructional decomposition and code motion. This paper addresses the semantic issues encountered when the Linda primitive, IN and RD, are decomposed and moved past other Linda operations. Formal semantics are given as well as results showing significant speedup (as high as 64%) when Instructional Footprinting is used.
  • Thumbnail Image
    Instructional footprinting: a basis for exploiting concurrency through instructional decomposition and code motion
    Landry, Kenneth D. (Virginia Tech, 1993-12-05)
    In many languages, the programmer is provided the capability of communicating through the use of function calls with other, separate, independent processes. This capability can be as simple as a service request made to the operating system or as advanced as Tuple Space operations specific to a Linda programming system. The problem with such calls, however, is that they block while waiting for data or information to be returned. This synchronous nature and lack of concurrency can be avoided by initiating a non-blocking request for data earlier in the code and retrieving the returned data later when it is needed. To facilitate a better understanding of how this type of concurrency can be exploited, we introduce an instructional footprint model and application framework that formally describes instructional decomposition and code motion activities. To demonstrate the effectiveness of such an approach, we apply instructional footprinting to programs using the Linda coordination language. Linda Primitive Transposition (LPT) and Instruction Piggybacking are discussed as techniques to increase the size of instructional footprints, and thereby improve the performance of Linda programs. We also present the concept of Lexical Proximity to demonstrate how the overlapping of footprints contributes to the speedup of Linda programs.
  • Thumbnail Image
    Instructional Footprinting: A Basis for Exploiting Concurrency Through Instructional Decomposition and Code Motion: A Research Prospectus
    Landry, Kenneth D.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    In many languages, the programmer is provided the capability of communicating, through the use of function calls, with other, separate, independent processes. This capability can be simple, as a service request made to the operating system, or more advanced, as Tuple space operations specific to a Linda programming system. The problem with such calls, however, is that they block while waiting for data of information to be returned. This synchronous nature and lack of concurrency can be avoided by initiating the request for data earlier in the code and retrieving the returned data later when it is needed. In order to facilitate this concurrency of processing, an instructional footprint model is developed which formally describes movement of instruction. This paper presents a proposal for research that involves the development of the instructional footprint model and an algorithmic framework in which to exploit concurrency in programming languages.
  • Thumbnail Image
    Instructional Footprinting: A Model for Exploiting Concurrency through Instructional Decomposition and Code Motion
    Landry, Kenneth D.; Arthur, James D. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    In many languages, the programmer is provided the capability of communicating, through the use of function calls, with other separate, independent processes. This capability can be as simple as a service request made to the operating system, or more advanced as Tuple Space operations specific to a Linda programming system. The problem with such calls, however, is that they block while waiting for data or information to be returned. This synchronous nature and lack of concurrency can be avoided by initiating the request for data earlier in the code and retrieving the returned data later when it is needed. In order to facilitate this concurrency of processing, an instructional footprint model is developed which formally describes movement of instructions. This paper presents research findings that entail the development of the instructional footprint model, an algorithmic framework in which to exploit concurrency in programming languages, and some preliminary results from applying the instructional footprint model.