A categorized bibliography on incremental computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Automated consistency checking of requirements specifications
ACM Transactions on Software Engineering and Methodology (TOSEM)
Experiences Using Lightweight Formal Methods for Requirements Modeling
IEEE Transactions on Software Engineering
Automatic generation of state invariants from requirements specifications
SIGSOFT '98/FSE-6 Proceedings of the 6th ACM SIGSOFT international symposium on Foundations of software engineering
Using Abstraction and Model Checking to Detect Safety Violations in Requirements Specifications
IEEE Transactions on Software Engineering
Specifying the mode logic of a flight guidance system in CoRE and SCR
FMSP '98 Proceedings of the second workshop on Formal methods in software practice
High-integrity code generation for state-based formalisms
Proceedings of the 22nd international conference on Software engineering
TAME: Using PVS strategies for special-purpose theorem proving
Annals of Mathematics and Artificial Intelligence
Program Synthesis from Formal Requirements Specifications Using APTS
Higher-Order and Symbolic Computation
Program Specialization via Program Slicing
Selected Papers from the Internaltional Seminar on Partial Evaluation
SCR*: A Toolset for Specifying and Analyzing Software Requirements
CAV '98 Proceedings of the 10th International Conference on Computer Aided Verification
Generating embedded software from hierarchical hybrid models
Proceedings of the 2003 ACM SIGPLAN conference on Language, compiler, and tool for embedded systems
SCR: A Practical Approach to Building a High Assurance COMSEC Syste
ACSAC '99 Proceedings of the 15th Annual Computer Security Applications Conference
A Survey of Program Slicing Techniques.
A Survey of Program Slicing Techniques.
An Algorithm for Strengthening State Invariants Generated from Requirements Specifications
RE '01 Proceedings of the Fifth IEEE International Symposium on Requirements Engineering
Compiling IOA without Global Synchronization
NCA '04 Proceedings of the Network Computing and Applications, Third IEEE International Symposium
An Esterel compiler for large control-dominated systems
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
Efficient type inference for secure information flow
Proceedings of the 2006 workshop on Programming languages and analysis for security
Proceedings of the 13th ACM conference on Computer and communications security
On the Role of Formal Methods in Software Certification: An Experience Report
Electronic Notes in Theoretical Computer Science (ENTCS)
FM '09 Proceedings of the 2nd World Congress on Formal Methods
SSS'06 Proceedings of the 8th international conference on Stabilization, safety, and security of distributed systems
Formal Methods in System Design
| Hi-index | 0.00 |
A promising trend in software development is the increasing adoption of model-driven design. In this approach, a developer first constructs an abstract model of the required program behavior in a language, such as Statecharts or Stateflow, and then uses a code generator to automatically transform the model into an executable program. This approach has many advantages---typically, a model is not only more concise than code and hence more understandable, it is also more amenable to mechanized analysis. Moreover, automatic generation of code from a model usually produces code with fewer errors than hand-crafted code.One serious problem, however, is that a code generator may produce inefficient code. To address this problem, this paper describes a method for generating efficient code from SCR (Software Cost Reduction) specifications. While the SCR tabular notation and tools have been used successfully to specify, simulate, and verify numerous embedded systems, until now SCR has lacked an automated method for generating optimized code. This paper describes an efficient method for automatic code generation from SCR specifications, together with an implementation and an experimental evaluation. The method first synthesizes an execution-flow graph from the specification, then applies three optimizations to the graph, namely, input slicing, simplification, and output slicing, and then automatically generates code from the optimized graph. Experiments on seven benchmarks demonstrate that the method produces significant performance improvements in code generated from large specifications. Moreover, code generation is relatively fast, and the code produced is relatively compact.