Performance Tools

QUESTIONS	XPRESS	TG X-Stack	DEGAS	D-TEC	DynAX	X-TUNE	GVR	CORVETTE	SLEEC	PIPER
What performance information would an application developer need to know about software developed in your X-Stack project?
What performance information would a code developer in your project need to know about your software?
What information should a performance tool gather from each level in your software stack? What performance information should each level of your software stack maintain for inspection by performance tools? How would a tool get this information: register a signal handler, call an async-signal safe function from a signal handler, register a callback, call a function from a registered callback, or something else?
What types of performance problems do you want tools to measure and diagnose? Insufficient parallelism? Serialization? Load-imbalance? Task dependences? Data movement costs? Power or energy consumption? Failures and failure handling costs? The overhead of resilience mechanisms (e.g., checkpointing)?
What kinds of performance problems do you foresee analyzing using post-mortem analysis?
What kinds of performance problems do you foresee analyzing using on-the-fly analysis? What interfaces will be needed to gather the necessary information? What control interfaces will be necessary to enable runtime adaptation based on performance measurements?
Current auto-tuning tools treat a program as a black-box. What kind of white-box performance analysis techniques do you envision would be helpful for auto-tuning application performance?
There is a gap between the application-level and implementation-level views of programming languages and DSLs. What information should your software layers (compiler and runtime system) provide to attribute implementation-level performance measurement data to an application-level view?
What kind of visualization and presentation support for bugs do you want from performance tools? Do you envision any IDE integration for performance tools?
List the performance challenges that you think the next generation programming languages and models would face?
How do you envision using performance feedback to reduce energy or power consumption? What sort of interfaces will that require for inquiry and control?
How can performance tools help with resilience?