Discussion Questions from CS 7390 Lecture

Date: 2/23/96 (Fri)

Presented by: Peter Lindstrom

Topic: Visualizing Concurrent Programs

Questions related to Miller's paper:

• The tone of the Miller paper seems negative and condescending toward the visualization community. It seems to me he wants to deflate much that is interesting from visualizations. I rebut this and suggest that fun in a visualization can help teach the pertinent info. in the visualization.
• Can we map the criteria to the fidelity of the visualization in terms of the taxonomy described in the first week of class?
• What was the point of the Miller paper? It was titled "An Essay on Parallel Program Visualization" but the paper hardly discussed parallel programs. All the heuristics given apply equally to non-parallel programs as parallel programs.
• Miller's paper presents very interesting views and comments about what is a good visualization. Is there any hints saying that a standardized model of visualization is appearing?
• Miller says that a visualization that `guides' leads you to discover things you didn't already know while one that `rationalizes' only illustrates things you already know, then says a tool is rationalizing if the user has to give the tool detailed instructions implying they already know how the program is working. But aren't there plenty of cases where the user must program the visualization to a detailed level but then, while watching the visualization, will notice behaviors and trends they weren't aware of?
• How can an abstract model result in an intuitive picture/visualization? It seems as if the more abstraction the less intuition we'd have. I would think that a metaphor would be a much better way of associating images with data. Also, how important is it that the model be intuitively understandable: as long as the model is consistent, we can learn how the model works, and if this is easier to learn/understand than the underlying stuff it represents, it will be useful.
• Guiding vs. Rationalizing: Miller makes the point that a guiding visualization should not need detailed instructions from the user (and that this is useful when visualizing a program when the user doesn't know everything about it). But it seems to me that you'd almost want the opposite: if you don't know everything about the program you want an interactive visualization so that you can explore it. If you're demonstrating how it works (since you already know) then a canned or non-interactive display is more appropriate.
• Miller argues that visualization should guide not rationalize, but without knowing what to be visualized, everything will be presented uniformly. How can that help visualization? Visualization and understanding are two parallel processes; they can hardly be separated from one another.

Questions related to the ParaGraph System (Heath & Etheridge)

• ParaGraph only looks at trace files of a program run previously. How could the system be ported to accept programs which are running concurrently? The nature of parallel systems make information gathering difficult. Also, the vis system itself can interfere with message traffic and disqualify the resulting behavior.
• Since ParaGraph relies on PICL to produce trace data on interesting events, like sending messages, is there a way to add more events by hand? Something like Polka's SendAlgoEvt.
• Since collecting trace data in PICL can add to overhead and cause incorrect time stamps when using ParaGraph, wouldn't the addition of extra tracemark events, which support user defined views, exacerbate the situation even more?
• In the ParaGraph system, they insist on the number of possible display available to the users. Doesn't also mean that there is no `good' way, on which everybody argues to represent the info, and that the burden of finding the appropriate representation is left to the user?
• Could any program that performs visualizations and animations of parallel processes run in real time? (With current technology) ParaGraph's displays will support up to 128 processors for most views (more with others), yet most graphics hardware cannot keep up with the real-time animation of even one processor.
• Is it inherently harder to come up with an effective view of parallel processes than to do so with a single process? Can views be designed that will be automatically scalable if more processors are applied to the problem?
• A large component of message traffic that leads to slowdowns is messages passing through processors on their way to others (most noticeable in nxm matrices). Do any systems allow programmers to see this behavior so algorithms can be better optimized to avoid it?
• Since ParaGraph is based on PICL, it requires just as much annotation as normal (if program not written originally in PICL) and is only as portable as PICL. This is like saying programs written with POLKA require no annotation, if you simply write it with POLKA to start with. Is there any better way to get portability?
• Heath and Etheridge claim that the relationship between simulation speed and execution speed is necessarily imprecise. What, if anything, can be done to try to make these speeds as close as possible?
• While a system like ParaGraph does present a large number of different displays, I wonder if it will be able to predict every possible display that the user would find useful. Has any work been done in supporting user-created displays outside of the algorithm animation genre? It seems they could be useful in helping to visualize less abstract data.
• In Heath and Etheridge's paper, they present many ways to visualize the behavior of parallel programs. Are these visualization methods the graphical representation of existing theoretical concepts or they are just figured to be useful by the authors? Is there any theoretical or empirical studies for all these visualization methods?