VisClient/org/hfbk/vis/visnode/VisPs.java

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dronus.gl.GLFont;
import org.dronus.gl.GLSphereRenderer;
import org.dronus.gl.GLTextPanel;
import org.dronus.gl.GLUtil;
import org.dronus.graph.Edge;
import org.dronus.graph.Graph;
import org.dronus.graph.Node;
import org.hfbk.util.Counter;
import org.hfbk.util.Sleeper;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class VisPs extends VisSet {
        
//      final int DELAY=10;  
        final int DELAY=1000;  
        
        Graph profile=new Graph();

        Counter<Integer> callCounter=new Counter<Integer>();
        
        //if something was sampled but not yet visualised.
        boolean dirty=true;
        
        class VisCallBall extends VisNodeDraggable {
                int dl;
                GLTextPanel helpText;           
                Node node;
                boolean isTriggered=true; 
                
                VisCallBall(Node n, Vector3f position) {
                        super(n, position);
                        this.node=n;
                        w=h=radius=1.6f;
                        helpText=new GLTextPanel(n.text,0,0);
                }
                
                void renderSelf() {
                        Integer count=callCounter.get(node.id);
                        if (count!=null){
                                radius=.3f+10*(float)Math.sqrt(count/(float)callCounter.total);
                                w=h=2*radius;
                        }
                        if (isHoovered || isTriggered)                          
                                GL11.glColor3f(1,1,1);
                        else if (node.type.equals("Process")){
                                boolean isOur=!node.text.startsWith("root:");
                                GL11.glColor3f(1,1,(isOur ? 1 : .5f ));                 
                        }
                        else if (node.type.equals("Call")){
                                boolean isOur=!node.text.startsWith("root:");
                                GL11.glColor4f(1,0,0,(isOur ? 1 : .5f ));
                        }
                                
                        GLSphereRenderer.renderSphere(radius);
                        
                        //if (isHoovered || radius>=1.6f) { //describe "fat" calls unhoovered also              
                        if (isHoovered) {
                                GL11.glTranslatef(radius,radius,0);
                                GLUtil.billboardCylinder();
                                GL11.glScalef(1,2,1);
                                GLFont.getDefault().render();                           
                                helpText.render();
                                GL11.glDisable(GL11.GL_TEXTURE_2D);
                        }
                        
                        isTriggered=false;
                }
        }
        
        VisNode create(Node node, Vector3f pos) {
                return new VisCallBall(node, pos);
        }
        
        public VisPs(Node dummy, Vector3f position) {   
                super(null, position);
                                
                profile.addNode(new Node("0","Vis/Client","Set"));
                
                Thread profiler=new Thread(){                   
                        public void run() {
                                setName("VisProfiler");
                                while(true){
                                        synchronized(VisPs.this){       profile();      };
                                        Sleeper.sleep(DELAY);
                                }
                        }
                };                              
                profiler.start();
        }
        
        void profile(){
                Node rootset=profile.getRoot();
                
                List<Node> activeNodes=new ArrayList<Node>();
                List<Edge> activeEdges=new ArrayList<Edge>();

                Runtime rt = Runtime.getRuntime();
            Process ps;
            InputStream is=null;
                
                HashMap<String,String[]> procs=new HashMap<String,String[]>();  

            
                try {
                        ps = rt.exec("ps -ef");
                    is = ps.getInputStream();
                try {
                        ps.waitFor();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                //System.out.println(ps.exitValue());
                //System.out.println(is);
                
                BufferedReader result = new BufferedReader(new InputStreamReader(is));
                String ln=result.readLine();
                while (ln!=null)
                {
                
                        ln=result.readLine();
                //      System.out.println(ln);
                        if (ln!=null)
                                {
                                String[] parts=ln.split(" +");
                                String powner=parts[0];
                                String PID=parts[1];
                                String PPID=parts[2];
                                String pname=parts[7];
                        //      System.out.println(owner+"--"+PID+"--"+PPID+"--"+pname);
                                String[] procinfo={PPID,pname,powner};
                                
                                procs.put(PID,procinfo);
                                
                                }
                }

                
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        
                activeNodes.clear();
                activeEdges.clear();
                
                for(Map.Entry<String,String[]> proc : procs.entrySet()){
//                      System.out.println(proc.getKey());
                        int procId= Integer.valueOf(proc.getKey() ).intValue(); 
                        String[] procInfo=proc.getValue();
                        Node procNode=profile.findNode(procId);
                        if(procNode==null) {
                                procNode=new Node(procId, procInfo[2]+":"+procInfo[1], "Process");
                                profile.addNode(procNode);
                                activeNodes.add(procNode);

                                profile.addEdge(new Edge(procNode,rootset, null, "in"));                                        
                        }

                        //for all elements of current thread's call stack...
                        Node last=null;
                                int parentid=Integer.valueOf(proc.getValue()[0] ).intValue();   
                                
                                callCounter.add(parentid); //count method sample
                                
                                Node n=profile.findNode(parentid); //know this method already?
                                
                                if (n==null){
                                        n=new Node(parentid, procInfo[2]+":"+procInfo[1],"Call");
                                        profile.addNode(n);             
                                        activeNodes.add(n);
                                        dirty=true; //mark for update
                                }       
                                Edge edgeNode =new Edge(n,rootset, null, "in");
                                profile.addEdge(edgeNode);
                                activeEdges.add(edgeNode);
                                
                                if (last!=null) //link to caller method 
                                        profile.addEdge(new Edge(last,n, null, ""));
                                else
                                        profile.addEdge(new Edge(n,procNode, null, "in"));
                                last=n;
                }
                
                profile.nodes.retainAll(activeNodes);
                profile.edges.retainAll(activeEdges);
        }
        
        void renderSelf() {
                super.renderSelf();
                //everytime the profiler added something to
                //profile graph, we update the visualisation.
                if (dirty) synchronized(this){
                        Node root=profile.getRoot();
                        update(root);
                        
                        dirty=false;
                }
        }
}

---