Design rules express constraints on the behavior and structure of a program. These rules can help ensure that a program follows a set of established practices, and avoids certain classes of errors.Design rules often crosscut program structure and enforcing them is emerging as an important application domain for Aspect Oriented Programming. For many interesting design rules, current general purpose AOP languages lack the expressiveness to characterize them statically and enforce them at compile time.We have developed a domain specific language called Program Description Logic (PDL). PDL allows succinct declarative definitions of programmatic structures which correspond to design rule violations. PDL is based on a fully static and expressive pointcut language. PDL pointcuts allow characterizing a wide range of design rules without sacrificing static verification.We evaluate PDL by comparing it to FxCop, an industrial strength tool for checking design rules.
This paper presents an effective dynamic processor self-scheduling scheme for general parallel program constructs in a restructuring compiler. In the program constructs, parallel loops, serial loops, IF-THEN-ELSE constructs and a generalization of FORK-JOINS can be nested in an arbitrary order, and procedure calls can be involved in any level of the nested constructs. In parallel programs, a piece of the program code is called a chore such as loop iterations, which is considered to be a work unit in the program. In our scheme, processors schedule themselves to the chores dynamically at execution time without involving the operating system.Memory management is another issue addressed in this paper. Efficiency concerns dictate treating chore locality differently from procedure locality. As a corollary in this paper, we have the following interesting result: the number of call frames required at any one time for a nonrecursive procedure is bounded by the number of processors. IntroductionThe advent of a wide variety of MIMD supercomputing systems has created the demand for software techniques to help exploit the new processing power. Much effort has been devoted to developing restructuring compilers and source-to-source translators that detect implicit parallelism in a "dusty deck" program and translate the program into parallel form. Such automatic parallelization is not always sufficient-the user often needs to code in parallelism. DOALL-loops and FORK-JOINS (or PARALLEL-DOS and PARALLEL-SECTIONS [9]) are common parallel constructs thus introduced, both explicitly and automatically. Besides much different parallel compiler technology, determining the granularity of a parallel program and scheduling different pieces of the program on multiple processors enhances performance.Classical static scheduling schemes, which assume fixed execution time of each iteration of the DO-loops, are not applicable in the restructuring parallel compilers. Execution time is widely various, due to the synchronization, memory and network contentions, and complicated program constructs. Since the user can code the explicit parallel constructs, the runtime model should restrict their use. For example, parallel loops should be nestable with each other, with other parallel constructs, and with all sequential constructs, including arbitrary control flow.Dynamic runtime scheduling seems to be the only alternative in the parallel programming environment. The overhead of the runtime scheduling system is higher than traditional static scheduling. Therefore, the effective runtime support of the dynamic scheduling will have a major impact on the success of a parallel compiler. Scheduling must be done with an intelligent tradeoff of small overhead against good workload balance.A macro package interacting with the operating system provides the simplest way to utilize multiple processors from within a single FORTRAN program (see Dongarra and Sorensen [7]). However, the overhead to start an operating system task is usually high, and geared to ...
As the cost of processor hardware declines, multiprocessor architectures become increasingly cost-effective and represent an important area for future research. In order to exploit the full potential of multiprocessors, however, it is necessary to understand how to design software which can make effective use of the available parallelism. This paper considers the impact of multiprocessor architecture on the design of high-level programming languages and, in particular, evaluates the language Ada in the light of the special requirements of realtime multiprocessor systems. We conclude that Ada does not, as currently designed, meet the needs for real-time embedded systems.
Praxis is the practice of the programming art, science, and skill. It is a high-order language designed for the efficient programming of control and systems applications. It is a comprehensive, strongly typed, block-structured language in the tradition of Pascal, with much of the power of the Mesa and Ada languages. It supports the development of systems composed cf separately compiled modules, user-defined data types, exception handling, detailed control mechanisms, and encapsulated data and routines. Direct access to machine facilities, efficient bit manipulation, and interlocked critical regions are provided within Praxis.
No abstract
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.