Static program analysis is the process of inferring information at compile-time on the runtime behavior of the program. Static program analysis has many important applications. It has traditionally been used primarily for optimizing programs so that they will run faster. More recently, program analysis is increasingly being used in tools to aid software development and it is extremely useful in finding bugs and security vulnerabilities in software. Although many promising advancements have been achieved, there are still many challenges in software reliability and development in the real world. One of the biggest issues is the lack of practical tools but the fact is that static program analysis is a very hard task. The current complexity of software makes sometimes existing static analysis tools unable to infer information in a reasonable amount of time. On the other hand, most problems in static program analysis are undecidable, which means the use of approximate algorithms is needed. To make these approximated algorithms work well on real programs is also a challenge. Background The usefulness and relevance of analyses which can infer information about the costs of computations is widely recognized since such information is useful in a large number of applications

Abstract machines provide a certain separation between platformdependent and platform-independent concerns in compilation. Many of the differences between architectures are encapsulated in the specific abstract machine implementation and the bytecode is left largely architecture independent. Taking advantage of this fact, we present a framework for estimating upper and lower bounds on the execution times of logic programs running on a bytecode-based abstract machine. Our approach includes a one-time, programindependent profiling stage which calculates constants or functions bounding the execution time of each abstract machine instruction. Then, a compile-time cost estimation phase, using the instruction timing information, infers expressions giving platform-dependent upper and lower bounds on actual execution time as functions of input data sizes for each program. Working at the abstract machine level makes it possible to take into account low-level issues in new architectures and platforms by just reexecuting the calibration stage instead of having to tailor the analysis for each architecture and platform. Applications of such predicted execution times include debugging/verification of time properties, certification of time properties in mobile code, granularity control in parallel/distributed computing, and resource-oriented specialization.

Many space applications such as sensor networks, on-board satellite-based platforms, on-board vehicle monitoring systems, etc. handle large amounts of data and analysis of such data is often critical for the scientific mission. Transmitting such large amounts of data to the remote control station for analysis is usually too expensive for time-critical applications. Instead, modern space

Abstract not found