added insn generated metric.
[dyninst.git] / dyninstAPI / src / process.h
1 /*
2  *  Copyright 1993 Jeff Hollingsworth.  All rights reserved.
3  *
4  */
5
6 /*
7  * process.h - interface to manage a process in execution. A process is a kernel
8  *   visible unit with a seperate code and data space.  It might not be
9  *   the only unit running the code, but it is only one changed when
10  *   ptrace updates are applied to the text space.
11  *
12  * $Log: process.h,v $
13  * Revision 1.7  1994/07/20 23:23:40  hollings
14  * added insn generated metric.
15  *
16  * Revision 1.6  1994/07/14  23:30:32  hollings
17  * Hybrid cost model added.
18  *
19  * Revision 1.5  1994/07/12  19:43:18  jcargill
20  * Changed order of processState defn, so that initial (==0) state is neonatal.
21  * Otherwise there is a small time-window at startup when it looks like it's
22  * running, but hasn't been initialized.
23  *
24  * Revision 1.4  1994/05/18  00:52:32  hollings
25  * added ability to gather IO from application processes and forward it to
26  * the paradyn proces.
27  *
28  * Revision 1.3  1994/03/31  01:58:33  markc
29  * Extended arguments to createProcess.
30  *
31  * Revision 1.2  1994/03/20  01:53:11  markc
32  * Added a buffer to each process structure to allow for multiple writers on the
33  * traceStream.  Replaced old inst-pvm.C.  Changed addProcess to return type
34  * int.
35  *
36  * Revision 1.1  1994/01/27  20:31:39  hollings
37  * Iinital version of paradynd speaking dynRPC igend protocol.
38  *
39  * Revision 1.6  1993/08/11  01:46:24  hollings
40  * added defs for baseMap.
41  *
42  * Revision 1.5  1993/07/13  18:29:49  hollings
43  * new include file syntax.
44  *
45  * Revision 1.4  1993/06/25  22:23:28  hollings
46  * added parent field to process.h
47  *
48  * Revision 1.3  1993/06/22  19:00:01  hollings
49  * global inst state.
50  *
51  * Revision 1.2  1993/06/08  20:14:34  hollings
52  * state prior to bc net ptrace replacement.
53  *
54  * Revision 1.1  1993/03/19  22:51:05  hollings
55  * Initial revision
56  *
57  *
58  */
59
60 #ifndef PROCESS_H
61 #define PROCESS_H
62
63 #include "util/h/list.h"
64 #include "rtinst/h/rtinst.h"
65 #include "dyninst.h"
66
67 typedef struct processRec process;
68
69 typedef enum { neonatal, running, stopped, exited } processState;
70
71 typedef struct freeListRec freeListEntry;
72
73 typedef enum { HEAPfree, HEAPallocated } heapStatus;
74
75 struct freeListRec {
76     int addr;
77     int length;
78     heapStatus status;
79     freeListEntry *next;
80 }; 
81
82 #define HIST_LIMIT      6
83
84 struct costRec {
85     float hybrid;
86     int currentHist;
87     float lastObservedCost;
88     float past[HIST_LIMIT];
89     float totalPredictedCost;
90     float currentPredictedCost;
91     time64 timeLastTrampSample;
92 };
93
94 struct processRec {
95     image *symbols;             /* information related to the process */
96     int traceLink;              /* pipe to transfer traces data over */
97     int ioLink;                 /* pipe to transfer stdout/stderr over */
98     processState status;        /* running, stopped, etc. */
99     int pid;                    /* id of this process */
100     int thread;                 /* thread id for thread */
101     Boolean aggregate;          /* is this process a pseudo process ??? */
102     freeListEntry *heap;        /* inferior heap */
103     freeListEntry *heapFreePtr; /* first free block heap */
104     resource rid;               /* handle to resource for this process */
105     process *parent;            /* parent of this proces */
106     List<void *> baseMap;       /* map and inst point to its base tramp */
107     char buffer[2048];
108     int bufStart;
109     int bufEnd;
110     struct costRec cost;
111 };
112
113 extern List<process*> processList;
114
115 process *createProcess(char *file, char *argv[], int nenv, char *envp[]);
116 process *allocateProcess(int pid, char *name);
117 process *findProcess(int pid);
118 void initInferiorHeap(process *proc, Boolean globalHeap);
119 void copyInferriorHeap(process *from, process *to);
120
121 int inferriorMalloc(process *proc, int size);
122 void inferriorFree(process *proc, int pointer);
123
124 #endif