trace.h

来自「标准的GP源代码,由Andy Singleton维护」· C头文件 代码 · 共 169 行

#ifndef TRACE_LIB
#define TRACE_LIB true
// trace.h   Class to give trace of prog execution on one test sequence
// [e-mail] $Revision: 1.4 $ 2 May 1995

//requires TRACE_RUN

//Modifications (reverse order):
// WBL  5 May 1995 Add trace_packed

class trace_run {
 private:
	int tree_used [NUM_TREES];
	int tree_ok [NUM_TREES];  //not that its correct just no fault found
	int tree_nak [NUM_TREES]; //not that its wrong just that it might be

 public:
inline	clear(){
		memset(tree_used,0,sizeof(tree_used)); 
		memset(tree_ok,  0,sizeof(tree_ok)); 
		memset(tree_nak, 0,sizeof(tree_nak)); };
inline	trace_run(){clear();}
inline	void trace(int tree) {tree_used[tree]++;};
inline	void trace_passed() {
		for (int i = 0; i<NUM_TREES; i++) {
			tree_ok[i]   += tree_used[i];
			tree_used[i]  = 0;}};
inline	void trace_failed() {
		for (int i = 0; i<NUM_TREES; i++) {
			tree_nak[i]  += tree_used[i];
			tree_used[i]  = 0;}};
inline	BOOL tree_tested(int tree) const { 
		return ((tree_ok[tree]!=0) || (tree_nak[tree]!=0));};
inline	int tree_passes(int tree) const { return tree_ok [tree];};
inline	int tree_fails (int tree) const { return tree_nak[tree];};
	friend ostream& operator<<(ostream&,trace_run&);
};//end class

extern      trace_run* ThisTrace;
//////////////////////////////////////////////////////////////////////

class trace_packed {
 private:
        struct packed_data {
		unsigned int ok0 : 2;//not that its correct just no fault found
		unsigned int ok1 : 2;
		unsigned int ok2 : 2;
		unsigned int ok3 : 2;
		unsigned int ok4 : 2;
		unsigned int ok5 : 2;
		unsigned int ok6 : 2;
		unsigned int ok7 : 2;
		unsigned int nak0: 2;//not that its wrong just that it might be
		unsigned int nak1: 2;
		unsigned int nak2: 2;
		unsigned int nak3: 2;
		unsigned int nak4: 2;
		unsigned int nak5: 2;
		unsigned int nak6: 2;
		unsigned int nak7: 2; };
	packed_data data[(NUM_TREES+7)/8];

inline void getaddress(int  tree, 
		       int& data_offset,   int& field ) const {
data_offset = tree/8;
field       = tree%8;
};

inline int  packed(int input) const {
	return (input==0) ?  0:
	       (input<=3) ?  1:
	       (input<=15)?  2:
	                     3;
};

inline int  unpacked(int input) const { 
	const int unpacked_data[4] = {0,2,8,64};
	return unpacked_data[input];
};

inline  void pack_ok (int tree, int input) {
        int data_offset, field;
        getaddress(tree, data_offset, field);
        const int packed_input = packed(input);
switch (field) {
 case  0: data[data_offset].ok0 = packed_input; break;
 case  1: data[data_offset].ok1 = packed_input; break;
 case  2: data[data_offset].ok2 = packed_input; break;
 case  3: data[data_offset].ok3 = packed_input; break;
 case  4: data[data_offset].ok4 = packed_input; break;
 case  5: data[data_offset].ok5 = packed_input; break;
 case  6: data[data_offset].ok6 = packed_input; break;
 case  7: data[data_offset].ok7 = packed_input; break;
};
};

inline  void pack_nak (int tree, int input) {
        int data_offset, field;
        getaddress(tree, data_offset, field);
        const int packed_input = packed(input);
switch (field) {
 case  0: data[data_offset].nak0 = packed_input; break;
 case  1: data[data_offset].nak1 = packed_input; break;
 case  2: data[data_offset].nak2 = packed_input; break;
 case  3: data[data_offset].nak3 = packed_input; break;
 case  4: data[data_offset].nak4 = packed_input; break;
 case  5: data[data_offset].nak5 = packed_input; break;
 case  6: data[data_offset].nak6 = packed_input; break;
 case  7: data[data_offset].nak7 = packed_input; break;
};
};

inline  int  raw_ok(int tree) const {
        int data_offset, field;
        getaddress(tree, data_offset, field);
switch (field) {
 case  0: return data[data_offset].ok0;
 case  1: return data[data_offset].ok1;
 case  2: return data[data_offset].ok2;
 case  3: return data[data_offset].ok3;
 case  4: return data[data_offset].ok4;
 case  5: return data[data_offset].ok5;
 case  6: return data[data_offset].ok6;
 case  7: return data[data_offset].ok7;
       };
};

inline  int  raw_nak(int tree) const {
        int data_offset, field;
        getaddress(tree, data_offset, field);
switch (field) {
 case  0: return data[data_offset].nak0;
 case  1: return data[data_offset].nak1;
 case  2: return data[data_offset].nak2;
 case  3: return data[data_offset].nak3;
 case  4: return data[data_offset].nak4;
 case  5: return data[data_offset].nak5;
 case  6: return data[data_offset].nak6;
 case  7: return data[data_offset].nak7;
       };
};


//inline	clear(){ memset(data, 0,sizeof(data)); };

 public:
//inline	trace_packed(){clear();}

inline  void trace_pack(trace_run* input) {
	for(int t = 0; t<NUM_TREES; t++) {
		pack_ok (t,input->tree_passes(t)); 
		pack_nak(t,input->tree_fails(t));
	};};

inline  int  unpack_ok(int tree) const {
	return unpacked(raw_ok(tree));
};

inline  int  unpack_nak(int tree) const {
	return unpacked(raw_nak(tree));
};

inline  BOOL used(int tree) const {
	return (raw_ok(tree) || raw_nak(tree));
};

};//end class trace_packed
#endif /*TRACE_LIB*/