typedef struct CALCULATION_STATE CALCULATION_STATE;

And then in your c-file just declare it as:

struct CALCULATION_STATE
{

}

And the second thing, why are you declaring the functions in your header file with extern keyword?
Maybe stupid questions, sorry for that, I’m not that skilled and I’m just missing something. :-)

I’ve wondered where the bottleneck is, but been too lazy to do any benchmarking to find out. I would not be surprised if there was a relatively large one per GPU dispatch, but that should only be a problem if we’re making lots of dispatches per image.

pyan.py by itself requires only Python 2.7. You can run it like: pyan.py demo.py --dot > demo.dot and then use GraphViz to layout demo.dot as an image file, for instance using the command dot -Tpng demo.dot > demo.png.

I’m not really sure where your pycallgraphis error is coming from…

I search for it but got nothing.
How can I use this pyan module to generate the graphs.lets say I have a python script name data.py in the desktop?
Is there any other dependency to run pyan.py ?

?- length(Expression, N), phrase(my_grammar, Expression).

The idea here is that the call to length/2 will enumerate all integers N in the order 0, 1, 2, …, bind Expression to a list of that length, and phrase/2 will then enumerate all words of my_grammar of that length. When that’s done, the next larger N is tried.

I guess as similar implementation would be possible in Python by threading a counter through all the generators, and there would be no need to invoke countability arguments.

https://yousource.it.jyu.fi/jjrandom2/miniprojects/trees/master/refactoring/pyan
https://yousource.it.jyu.fi/jjrandom2/miniprojects/trees/master/refactoring/xdot

The top-level directory

https://yousource.it.jyu.fi/jjrandom2/miniprojects/trees/master/refactoring

contains a combined README and a wrapper script (analyze.sh) for convenience.

By the way, I have now modified XDot, too. The new version comes with an incremental Find feature (handy for looking for nodes by label text), and highlights outgoing/incoming linked nodes (if modifiers held down) when hovering over nodes. It also has some new UI animations, the UI has been generally polished, and it has built-in documentation.

I just posted about the changes to the original site ( http://code.google.com/p/jrfonseca/wiki/XDot ), currently waiting if there is an interest.

Check it out (no pun intended) if you or any of the readers are interested. It’s available at:

https://yousource.it.jyu.fi/jjrandom2/miniprojects/trees/master/refactoring/

The only case where I’ve gotten it to trip up was to (out of curiosity) feed it pyan.py and xdot.py at the same time – both of them happen to contain a class named Node, and this generates some spurious links between the two pieces of software that should be completely disconnected. It’s not exactly a real-world use case, and I didn’t have any immediate ideas as to how to fix it (hmm – maybe prefer nodes within the same namespace hierarchy?), so I decided to leave it as-is.

Ok, I’ll keep it in my repository.

And thanks for the new post with screenshots :)

The .tgf format is obsolete, I just picked it because I wanted to see how effective the yEd layouts were, and .tgf was easiest to implement. I should replace it with .graphml format, which would support the additional options you’ve added for .dot.

You can keep it in your git repository, since you are more likely to write more improvements — I’ll just copy the pyan.py changes for now. If I make any major improvements myself I’ll post about them here.

Thanks for a great tool!

I was looking for a tool to make call graphs for Python, and pyan fits the bill almost exactly. Combined with the “fdp” (spring model) filter of GraphViz, and the interactive xdot viewer, it’s a nice help for refactoring (specifically, looking for mostly-independent subsets of functions for splitting a large module).

Inspired by your screenshot at the end of the post, I made a modified version of pyan with some added features that may help when working with large projects.

The modified version has command-line options to:

- Color nodes automatically. A HSL color model is used, picking the hue based on the top-level namespace (effectively, the module). The colors start out light, and then darken for each level of nesting. Seven different hues are available, cycled automatically.

- Group nodes in the same namespace. GraphViz clusters are used for this. The namespace name is used as the cluster label. Groups can be created as standalone (always inside top-level graph) or nested. The nested mode follows the namespace structure of the code.

- Disable generation of links for “defines” relationships. This can make the resulting graph look much clearer, when there are a lot of “uses” relationships. This is especially useful for layout with “fdp”.

- Disable generation of links for “uses” relationships. Can be useful for visualizing just where functions are defined.

Also, now the “defines” relations are drawn with gray arrows, so that it’s easier to visually tell them apart from the “uses” relations when there are a lot of edges of both types in the graph.

Nodes are now always filled (white if color disabled), and made translucent to clearly show arrows passing underneath them. This is useful for large graphs with the fdp filter.

With the exception of the disable switches, which support both output formats, all modifications are for GraphViz output only.

The modified version is available at:

https://yousource.it.jyu.fi/jjrandom2/miniprojects/blobs/master/refactoring/pyan.py

As it stands, the added code is a bit messy. Tell me if you want to integrate the changes, and we can see if it can be cleaned up sufficiently. :)

http://www.cs.auckland.ac.nz/~ewan/essays/se_vs_cs/

Cheers Craig