replaced exclude_func and exclude_lib with exclude_node
[dyninst.git] / paradyn / src / DMthread / DMresource.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #ifndef DMresource_H 
43 #define DMresource_H
44 #ifndef NULL
45 #define NULL 0
46 #endif
47
48 extern "C" {
49 #include <malloc.h>
50 #include <unistd.h>
51 #include <assert.h>
52 }
53
54 #include "util/h/Vector.h"
55 #include "util/h/Dictionary.h"
56 #include "dataManager.thread.h"
57 #include "dataManager.thread.SRVR.h"
58 #include "DMabstractions.h"
59 #include "DMinclude.h"
60
61 //
62 //class resource: the static items basically manage a "database" of all
63 //resources. the non-static stuff gives you information about a single resource.
64 //note: In the "database", resources can be created, but never destroyed.
65 //
66 class resource {
67       friend class dataManager;
68       friend class performanceStream;
69       friend class resourceList;
70       friend void printAllResources();
71       friend class dynRPCUser;
72       friend string DMcreateRLname(const vector<resourceHandle> &res);
73       friend resourceHandle createResource(unsigned, vector<string>&, string&, unsigned);
74       friend resourceHandle createResource_ncb(vector<string>&, string&, unsigned, 
75                                         resourceHandle&, bool&);
76       friend void getMemoryBounds(vector<metric_focus_pair> *request) ;
77
78   public:
79     vector<resourceHandle> *getChildren();
80     const char *getName() const { 
81         return(fullName[fullName.size()-1].string_of());}
82     const char *getFullName() const { return(name.string_of()); }
83     const char *getAbstractionName() const { 
84         if (abstr) return(abstr->getName());
85         return 0;       
86     }
87     unsigned getType() const { return type; }
88     resourceHandle *findChild(const char*) const;
89     bool match(const string &ptr) const { return(ptr == name); }
90     bool isDescendent(resourceHandle child) const;
91     bool isDescendantOf(const resource &other) const;
92     bool sameRoot(resourceHandle other) const;
93     void print();
94     resourceHandle getParent() const { return(parent); }
95     void setSuppress(bool newValue){ suppressSearch = newValue; }
96     void setSuppressChildren(bool newValue){ suppressChildSearch = newValue;}
97     bool getSuppress() const { return(suppressSearch); }
98     bool getSuppressChildren() const { return(suppressChildSearch); }
99     abstraction *getAbstraction() { return(abstr); }
100     bool isMagnifySuppressed() { return (suppressMagnify); }
101     void setSuppressMagnify() {suppressMagnify = true;}
102     void clearSuppressMagnify() {suppressMagnify = false;}
103
104     void AddChild(resourceHandle r){ children += r; }
105     resourceHandle getHandle() const {return(res_handle);}
106     static bool string_to_handle (const string &res,resourceHandle *h);
107     static const char *getName(resourceHandle);
108     static const char *getFullName(resourceHandle);
109     const vector<string>& getParts() const {return fullName;}
110     static bool get_lib_constraints(vector<string>&);
111     static bool get_func_constraints(vector< vector<string> >&);
112     static void saveHierarchiesToFile (ofstream& foo);
113     void saveHierarchyToFile (ofstream& foo);
114
115   protected:
116     resource();
117     resource(resourceHandle p_handle,
118              unsigned tempId, // the temporary id generated by the daemon
119              vector<string>& resource_name,
120              string& r_name,
121              string& abstr, unsigned type);
122     resource(resourceHandle p_handle,
123              vector<string>& resource_name,
124              string& r_name,
125              string& abstr, unsigned type);
126     ~resource(){}
127   private:
128     string name;
129     unsigned type;   // MDL type of this resource (MDL_T_INT, MDL_T_STRING, etc)
130     resourceHandle res_handle;  
131     resourceHandle parent;  
132     vector<string> fullName; 
133     bool suppressSearch;
134     bool suppressChildSearch;
135
136     bool suppressMagnify;  // true if mdl exclude_lib option specifies this 
137     abstraction *abstr;  // TODO: change this to a handle later
138     vector<resourceHandle> children; 
139     static dictionary_hash<string, resource*> allResources;
140     static dictionary_hash<unsigned, resource*> resources;  // indexed by resourceHandle
141     static resource *rootResource;
142     static vector<string> lib_constraints;
143     // each element is a module string and a function string
144     static vector< vector<string> > func_constraints;
145     static bool func_constraints_built;
146     static bool lib_constraints_built;
147
148     static resource *handle_to_resource(resourceHandle);
149     static resource *string_to_resource(const string &);
150 };
151
152 // 
153 // a resourceList can be created, but never destroyed
154 //
155 class resourceList {
156       friend class metricInstance;
157       friend class dataManager;
158       friend class paradynDaemon;
159   public:
160       // resourceList(string name); 
161       resourceList(const vector<resourceHandle> &resources); 
162       resourceList(const vector<string> &names); 
163       bool getNth(int n,resourceHandle *h) const {
164           if(n < (int)(elements.size())){
165               *h = (elements[n])->getHandle();
166               return TRUE;
167           }
168           return FALSE;
169       }
170       resourceListHandle getHandle() const {return(id);}
171       int getCount() const { return(elements.size()); }
172       void print();
173       const char *getName() const {return(fullName.string_of());}
174
175       bool convertToStringList(vector< vector<string> >& fs);
176       bool convertToIDList(vector<resourceHandle>& flist);
177       bool isSuppressed(){return(suppressed);}
178
179       vector<rlNameId> *magnify(resourceHandle rh);
180       vector<rlNameId> *magnify();
181       resourceListHandle *constrain(resourceHandle);
182
183       bool getMachineNameReferredTo(string &machName) const;
184          // If this focus is specific to a machine, then fill in "machName"
185          // and return true.  Else, leave "machName" alone and return false.
186          // What does it mean for a focus to be specific to a machine?
187          // For one, if the focus is a descendant of a machine, then it's 
188          // obvious.  If the focus is a descendant of a process, then we can
189          // find a machine to which it's referring, too.
190          // NOTE: If this routine gets confused or isn't sure whether the
191          // resource is  specific to a machine, it returns false.
192
193       static const char *getName(resourceListHandle rh);
194       static bool convertToIDList(resourceListHandle rh,
195                                   vector<resourceHandle> &rl);
196       static vector<resourceHandle> *getResourceHandles(resourceListHandle);
197          // returns NULL if getFocus(resourceListHandle) fails, else
198          // returns a vector allocated with new (which the caller must delete!)
199
200       static const resourceListHandle *find(const string &name);
201       // creates new resourceList if one doesn't already exist 
202       static resourceListHandle getResourceList(const vector<resourceHandle>&);
203   private:
204       resourceListHandle id;
205       vector<resource*> elements;
206       string fullName;
207       bool suppressed;
208       static vector<resourceList *> foci;  // indexed by resourceList id
209       static dictionary_hash<string,resourceList *> allFoci;
210       static resourceList *getFocus(resourceListHandle handle){
211             if(handle < foci.size())
212                     return(foci[handle]);
213             return 0;
214       }
215       static resourceList *findRL(const char *name);
216 };
217
218 #endif
219