branch_profile.cpp

Go to the documentation of this file.

/*
        Copyright (C) 1997 CFU Corporation

        File: branch_profile.cpp
        Author: Matt Jennings from Chao-ying Fu's value_profile.h
        Date: March 17 1999

        ^..^
        (00)

         $__$
        <~00~>
         (oo)
          ||

        ```````
        C ^|^ D
         \ O /
*/

#include <math.h>
#include "branch_profile.h"
#include "node_table.h"
#include "util.h"
#include <assert.h>
#include <legoUtil.H>
#include "lego_util.h"
#include "predicate.h"

//#define BRANCHDEBUG

#ifdef BRANCHDEBUG
#define BRANCHLEVEL 0
#define Bdb(level,format,args...) (BRANCHLEVEL>=level)?emit_message(format,##args):NULL
#define Bdb_call(level,args) (BRANCHLEVEL>=level)?args:NULL
#else
#define Bdb(level,format,args...)
#define Bdb_call(level,args)
#endif  //BRANCHDEBUG

//
// interested_opcode: operations to be profiled
//
void Branch_Profile::doit(legoModule *module_ptr,int interested_opcode)
{
        Bdb(1,"Branch_Profile::doit");

        Predicate::init_true_predicate_oprd();

        int proc_count=module_ptr->GetCount();


        FILE *table_fp;
        unsigned int start_index;

        for(int i=0;i<proc_count;i++)
        {
                legoProc *proc_ptr;
                proc_ptr=(legoProc *)module_ptr->GetItem(i);
                assert(proc_ptr->GetRegionType()==RT_PROC);

                if(strcmp(proc_ptr->GetProcName(),"_main")==0)
                {
                        instrument_main(module_ptr,proc_ptr);
                }


                Node_Table *node_table;
                node_table=new Node_Table();
                if(i==0)
                {
                        node_table->open_file("BRaNCH_PT");
                        table_fp=node_table->node_table_fp();
                }
                else
                {
                        node_table->set_node_table_fp(table_fp);
                        node_table->set_start_index(start_index);
                }
                node_table->set_proc_name(proc_ptr->GetProcName());


                int num_of_interested_ops=0;

                Bdb(3,"%s",proc_ptr->GetProcName());
                int region_count=proc_ptr->GetCount();
                for(int j=0;j<region_count;j++)
                {
                        legoRegion *region_ptr=(legoRegion *)proc_ptr->GetItem(j);
                        if (IS_BLOCK( region_ptr->GetRegionType() ) ) {
                          Bdb(3,"region_id %d",region_ptr->GetRegionId());
                          opList *entry_op_list=region_ptr->GetEntryOpsPtr();
                          legoOp *op_ptr=entry_op_list->GetOpPtr();
                          for(;op_ptr!=NULL;op_ptr=op_ptr->GetNextLink())
                            {
                              int op_code=op_ptr->GetOpcode();
                              Bdb(3,"%s",ParseMap(op_code));
                              
                              if(op_code==BRCT)
                                {
                                  num_of_interested_ops++;
                                }
                            }
                        }
                        else { // otherwise this is a treegion
                          int treegion_bb_count=region_ptr->GetCount();
                          for(int k=0;k<treegion_bb_count;k++) {
                            legoRegion *treegion_bb_ptr=(legoRegion *)region_ptr->GetItem(k);
                            Bdb(3,"region_id %d",treegion_bb_ptr->GetRegionId());
                            opList *entry_op_list=treegion_bb_ptr->GetEntryOpsPtr();
                            legoOp *op_ptr=entry_op_list->GetOpPtr();
                            for(;op_ptr!=NULL;op_ptr=op_ptr->GetNextLink())
                              {
                                int op_code=op_ptr->GetOpcode();
                                Bdb(3,"%s",ParseMap(op_code));
                                
                                if(op_code==BRCT)
                                  {
                                    num_of_interested_ops++;
                                  }
                              }
                          }
                        }
                }

                Bdb(3,"num_of_interested_ops=%d",num_of_interested_ops);

                node_table->add_num_of_entries(num_of_interested_ops);

                instrument(proc_ptr,node_table,interested_opcode);

                start_index=node_table->start_index();
                node_table->print(node_table->node_table_fp());
                Bdb_call(3,node_table->print(stderr));
                Bdb_call(3,getchar());
        }

        fclose(table_fp);

        open_main_file(start_index);
        open_header_file();
        close_main_file();
        close_header_file();
}

//
// Create an attribute
// Ex:   
// lc ^287 ({"tr" (m<int_p1> m<int_p2> m<int_p3>)}{"ret" (m<ret_addr>)})
//
attrs *Branch_Profile::write_attribute(legoProc *proc_ptr)
{
        attrs *attrs_ptr=proc_ptr->GetAttrDictionary();

        while(attrs_ptr->GetNextAttrPtr()!=NULL)
        {
                attrs_ptr=attrs_ptr->GetNextAttrPtr();
        }

        int new_attr_id=attrs_ptr->GetAttrId()+1;

        attrs *new_attr=new attrs();
        new_attr->SetAttrType(ATTR_LC);
        new_attr->SetAttrId(new_attr_id);
        new_attr->SetAttrString("tr");

        legoOprd *dest_p1_oprd=new legoOprd();
        dest_p1_oprd->SetOprdType(OT_MACRO);
        dest_p1_oprd->SetOprdRegNum(INT_P1);

        legoOprd *dest_p2_oprd=new legoOprd();
        dest_p2_oprd->SetOprdType(OT_MACRO);
        dest_p2_oprd->SetOprdRegNum(INT_P2);

        dest_p1_oprd->SetNextOprdPtr(dest_p2_oprd);

        legoOprd *dest_ret_oprd=new legoOprd();
        dest_ret_oprd->SetOprdType(OT_MACRO);
        dest_ret_oprd->SetOprdRegNum(RET_ADDR);

        new_attr->SetAttrOprdPtr(dest_p1_oprd);

        attrs *next_lc=new attrs();
        next_lc->SetAttrType(ATTR_LC);
        next_lc->SetAttrId(new_attr_id);
        next_lc->SetAttrString("ret");
        next_lc->SetAttrOprdPtr(dest_ret_oprd);

        new_attr->SetNextLcEntryPtr(next_lc);
        attrs_ptr->SetNextAttrPtr(new_attr);

        Bdb_call(3,WriteAttrs(proc_ptr,stderr));

        return new_attr;
}

void Branch_Profile::instrument(legoProc *proc_ptr,Node_Table *node_table,int interested_opcode)
{
        int max_reg1=find_max_reg_num(proc_ptr)+1;
        int max_reg2=max_reg1 + 1;
        int max_reg3=max_reg2 + 1;
        

        int region_count=proc_ptr->GetCount();
        for(int j=0;j<region_count;j++)
        {
                legoRegion *region_ptr=(legoRegion *)proc_ptr->GetItem(j);
                if (IS_BLOCK( region_ptr->GetRegionType() ) ) {
                  Bdb(3,"region_id %d",region_ptr->GetRegionId());
                  opList *entry_op_list=region_ptr->GetEntryOpsPtr();
                  legoOp *from_op_ptr=entry_op_list->GetOpPtr();
                  for(;from_op_ptr!=NULL;from_op_ptr=from_op_ptr->GetNextLink())
                    {
                      int from_op_code=from_op_ptr->GetOpcode();
                      Bdb(3,"%s",ParseMap(from_op_code));
                      
                      if(from_op_code==BRCT)
                        {
                          unsigned int mapping=node_table->start_index();
                          
                          legoOprd *taken_oprd=from_op_ptr->GetSrcOprdPtr()->GetNextOprdPtr();
                          
        //
        // For PBRR, branch target register
        //
        legoOprd *address_oprd=new legoOprd();
        address_oprd->SetOprdType(OT_REG);
        address_oprd->SetOprdRegType(RT_R);
        address_oprd->SetOprdRegNum(max_reg1);
        address_oprd->SetOprdFileType(FT_BTR);
        address_oprd->SetOprdDataType(DT_B);

        legoOprd *save_p1_oprd=new legoOprd();
        save_p1_oprd->SetOprdType(OT_REG);
        save_p1_oprd->SetOprdRegType(RT_R);
        save_p1_oprd->SetOprdRegNum(max_reg2);
        save_p1_oprd->SetOprdFileType(FT_GPR);
        save_p1_oprd->SetOprdDataType(DT_I);

        legoOprd *save_p2_oprd=new legoOprd();
        save_p2_oprd->SetOprdType(OT_REG);
        save_p2_oprd->SetOprdRegType(RT_R);
        save_p2_oprd->SetOprdRegNum(max_reg3);
        save_p2_oprd->SetOprdFileType(FT_GPR);
        save_p2_oprd->SetOprdDataType(DT_I);

        legoOprd *dest_p1_oprd=new legoOprd();
        dest_p1_oprd->SetOprdType(OT_MACRO);
        dest_p1_oprd->SetOprdRegNum(INT_P1);

        legoOprd *dest_p2_oprd=new legoOprd();
        dest_p2_oprd->SetOprdType(OT_MACRO);
        dest_p2_oprd->SetOprdRegNum(INT_P2);

        legoOprd *dest_ret_oprd=new legoOprd();
        dest_ret_oprd->SetOprdType(OT_MACRO);
        dest_ret_oprd->SetOprdRegNum(RET_ADDR);

        attrs *attr_ptr=write_attribute(proc_ptr);
        attrList *attr_list=new attrList();
        attr_list->SetAttrPtr(attr_ptr);
        attr_list->SetAttrType(attr_ptr->GetAttrType());
        attr_list->SetAttrId(attr_ptr->GetAttrId());
        attr_list->SetValid(1);

                          insert_branch_predictor(mapping,proc_ptr,region_ptr,address_oprd,save_p1_oprd,dest_p1_oprd,save_p2_oprd,dest_p2_oprd,Predicate::true_predicate_oprd(),from_op_ptr,taken_oprd,"_MY_BRaNCH_PRoBe",attr_list,dest_ret_oprd);
                          
                          
                          node_table->add_entry(from_op_ptr->GetOpId());
                        }
                      
                    }
                }
                else { // otherwise this is a treegion
                  int treegion_bb_count=region_ptr->GetCount();
                  for(int k=0;k<treegion_bb_count;k++) {
                    legoRegion *treegion_bb_ptr=(legoRegion *)region_ptr->GetItem(k);
                    Bdb(3,"region_id %d",treegion_bb_ptr->GetRegionId());
                    opList *entry_op_list=treegion_bb_ptr->GetEntryOpsPtr();
                    legoOp *from_op_ptr=entry_op_list->GetOpPtr();
                    for(;from_op_ptr!=NULL;from_op_ptr=from_op_ptr->GetNextLink())
                      {
                        int from_op_code=from_op_ptr->GetOpcode();
                        Bdb(3,"%s",ParseMap(from_op_code));
                        
                        if(from_op_code==BRCT)
                          {
                            unsigned int mapping=node_table->start_index();
                            
                            legoOprd *taken_oprd=from_op_ptr->GetSrcOprdPtr()->GetNextOprdPtr();
                            
        //
        // For PBRR, branch target register
        //
        legoOprd *address_oprd=new legoOprd();
        address_oprd->SetOprdType(OT_REG);
        address_oprd->SetOprdRegType(RT_R);
        address_oprd->SetOprdRegNum(max_reg1);
        address_oprd->SetOprdFileType(FT_BTR);
        address_oprd->SetOprdDataType(DT_B);

        legoOprd *save_p1_oprd=new legoOprd();
        save_p1_oprd->SetOprdType(OT_REG);
        save_p1_oprd->SetOprdRegType(RT_R);
        save_p1_oprd->SetOprdRegNum(max_reg2);
        save_p1_oprd->SetOprdFileType(FT_GPR);
        save_p1_oprd->SetOprdDataType(DT_I);

        legoOprd *save_p2_oprd=new legoOprd();
        save_p2_oprd->SetOprdType(OT_REG);
        save_p2_oprd->SetOprdRegType(RT_R);
        save_p2_oprd->SetOprdRegNum(max_reg3);
        save_p2_oprd->SetOprdFileType(FT_GPR);
        save_p2_oprd->SetOprdDataType(DT_I);

        legoOprd *dest_p1_oprd=new legoOprd();
        dest_p1_oprd->SetOprdType(OT_MACRO);
        dest_p1_oprd->SetOprdRegNum(INT_P1);

        legoOprd *dest_p2_oprd=new legoOprd();
        dest_p2_oprd->SetOprdType(OT_MACRO);
        dest_p2_oprd->SetOprdRegNum(INT_P2);

        legoOprd *dest_ret_oprd=new legoOprd();
        dest_ret_oprd->SetOprdType(OT_MACRO);
        dest_ret_oprd->SetOprdRegNum(RET_ADDR);

        attrs *attr_ptr=write_attribute(proc_ptr);
        attrList *attr_list=new attrList();
        attr_list->SetAttrPtr(attr_ptr);
        attr_list->SetAttrType(attr_ptr->GetAttrType());
        attr_list->SetAttrId(attr_ptr->GetAttrId());
        attr_list->SetValid(1);

                            insert_branch_predictor(mapping,proc_ptr,treegion_bb_ptr,address_oprd,save_p1_oprd,dest_p1_oprd,save_p2_oprd,dest_p2_oprd,Predicate::true_predicate_oprd(),from_op_ptr,taken_oprd,"_MY_BRaNCH_PRoBe",attr_list,dest_ret_oprd);
                            
                            
                            node_table->add_entry(from_op_ptr->GetOpId());
                          }
                      } 
                  }
                }
        }
}

//
// Insert branch predictor before from_op_ptr
// int_p1 contains index (mapping) 
// int_p2 contains taken or not-taken from predicate register
//
// Ex:
// op 184 (MOVE [r<84:i gpr>] [m<int_p1>] p<t>)
// op 185 (MOVE [r<85:i gpr>] [m<int_p2>] p<t>)
// op 186 (MOVE [m<int_p1>] [i<0>] p<t>)
// op 187 (MOVEPG [m<int_p2>] [r<11:i pr>] p<t>)
// op 188 (PBRR [r<83:b btr>] [l:g_abs<_MY_BRaNCH_PRoBe>] p<t>)
// op 189 (BRL [m<ret_addr>] [r<83:b btr>] p<t> attr(lc ^287))
// op 190 (MOVE [m<int_p1>] [r<84:i gpr>] p<t>)
// op 191 (MOVE [m<int_p2>] [r<85:i gpr>] p<t>)
//
void Branch_Profile::insert_branch_predictor(int index,legoProc *proc_ptr,legoRegion *region_ptr,legoOprd *address_oprd,legoOprd *save_p1_oprd,legoOprd *dest_p1_oprd,legoOprd *save_p2_oprd,legoOprd *dest_p2_oprd,legoOprd *predicate_oprd,legoOp *from_op_ptr,legoOprd *taken_oprd,char *probe_name,attrList *attr_list,legoOprd *dest_ret_oprd)
{
        int max_op_id=(FindMaxOpId(proc_ptr))->GetOpId()+1;

        //
        // Step 1: Save int_p1 register
        // ex: op 184 (MOVE [r<84:i gpr>] [m<int_p1>] p<t>)
        //
        legoOp *new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(dest_p1_oprd);
        new_op_ptr->SetDestOprdPtr(save_p1_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 2: Save int_p2 register
        // ex: op 185 (MOVE [r<85:i gpr>] [m<int_p2>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(dest_p2_oprd);
        new_op_ptr->SetDestOprdPtr(save_p2_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 4: Set int_p1 to index
        // ex: op 187 (MOVE [m<int_p1>] [i<0>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        legoOprd *src_oprd=new legoOprd();
        src_oprd->SetOprdType(OT_LITERAL_I);
        src_oprd->SetLiteralInteger(index);

        new_op_ptr->SetSrcOprdPtr(src_oprd);
        new_op_ptr->SetDestOprdPtr(dest_p1_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 5: Set int_p2 to predicate of BRCT (taken if T, not-taken if F)
        // ex: op 188 (MOVEPG [m<int_p2>] [r<11:i pr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        //new_op_ptr->SetOpcode(MOVEPG);
        new_op_ptr->SetOpcode(MOVE);
        new_op_ptr->SetSrcOprdPtr(taken_oprd);
        new_op_ptr->SetDestOprdPtr(dest_p2_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 7: Prepare to branch
        // ex: op 190 (PBRR [r<83:b btr>] [l:g_abs<_MY_BRaNCH_PRoBe>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(PBRR);

        src_oprd=new legoOprd();
        src_oprd->SetOprdType(OT_LITERAL_L);
        src_oprd->SetLiteralLabel(probe_name);
        src_oprd->SetLiteralAddrStyle(AS_G_ABS);

        new_op_ptr->SetSrcOprdPtr(src_oprd);
        new_op_ptr->SetDestOprdPtr(address_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        Bdb_call(2,WriteOps(new_op_ptr,1,stderr,0));
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 8: Branch and link
        // ex: op 191 (BRL [m<ret_addr>] [r<83:b btr>] p<t> attr(lc ^287))
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(BRL);

        new_op_ptr->SetSrcOprdPtr(address_oprd);
        new_op_ptr->SetDestOprdPtr(dest_ret_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetOpAttrListPtr(attr_list);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 9: Restore int_p1
        // ex: op 192 (MOVE [m<int_p1>] [r<84:i gpr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(save_p1_oprd);
        new_op_ptr->SetDestOprdPtr(dest_p1_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

        //
        // Step 10: Restore int_p2
        // ex: op 193 (MOVE [m<int_p2>] [r<85:i gpr>] p<t>)
        //
        new_op_ptr=new legoOp(max_op_id++);
        new_op_ptr->SetOpcode(MOVE);

        new_op_ptr->SetSrcOprdPtr(save_p2_oprd);
        new_op_ptr->SetDestOprdPtr(dest_p2_oprd);
        new_op_ptr->SetPredOprdPtr(predicate_oprd);
        new_op_ptr->SetSchedTime(from_op_ptr->GetSchedTime());

        //WriteOps(new_op_ptr,1,stderr,0);
        insert_new_op_before(region_ptr,proc_ptr,from_op_ptr,new_op_ptr);

}

void Branch_Profile::instrument_main(legoModule *module_ptr,legoProc *proc_ptr)
{
        //
        // Update symbolTable (ms text)
        //
        symbolTable *text_ptr=module_ptr->GetTextPtr();
        Bdb_call(3,text_ptr->WriteRebel(stderr));

        for(int i=0;i<text_ptr->GetVarCount();i++)
        {
                nameTable *nt=text_ptr->GetVarTablePtr(i);
                if(strcmp(nt->GetVarName(),"_main")==0)
                {
                        Bdb_call(3,nt->WriteRebel(stderr));
                        nt->SetVarName("_MaiN");
                        Bdb_call(3,nt->WriteRebel(stderr));
                }
        }

        //
        // Update proc name
        //
        proc_ptr->SetProcName("_MaiN");
}


void Branch_Profile::lego_write(legoModule *module_ptr,char *input_filename)
{
        Bdb(1,"Branch_Profile::lego_write");
        char *output_filename=new char[strlen(input_filename)+7];
        strcpy(output_filename,input_filename);

        int i=strlen(input_filename)-3;

        output_filename[i+0]='_';
        output_filename[i+1]='B';
        output_filename[i+2]='R';
        output_filename[i+3]='a';
        output_filename[i+4]='N';
        output_filename[i+5]='C';
        output_filename[i+6]='H';
        output_filename[i+7]='.';
        output_filename[i+8]='e';
        output_filename[i+9]='l';
        output_filename[i+10]='\0';

        LegoWrite(module_ptr,output_filename);
}

void Branch_Profile::open_main_file(unsigned int max_entry)
{
        _main_fp=fopen(BRANCH_MAIN_FILENAME,"w");

        if(_main_fp==NULL)
        {
                fprintf(stderr,"Error open file:%s\n",BRANCH_MAIN_FILENAME);
                exit(0);
        }

        fprintf(_main_fp,"/*\n\tFile: %s\n",BRANCH_MAIN_FILENAME);
        fprintf(_main_fp,"\tAuthor: Matt Jennings from Chao-ying Fu's VaLue_PRoFiLe.c\n");
        fprintf(_main_fp,"\tDate: March 17, 1999\n*/\n\n");
        fprintf(_main_fp,"#define MAX_ENTRY %u\n\n",max_entry);

        unsigned int max_predictor_entry=0;

        if(max_entry>0)
        {
                max_predictor_entry=1<<(unsigned int)ceil(log(max_entry)/log(2));
        }
        else
        {
                fprintf(stderr,"max_entry==0\n");
        }

        fprintf(_main_fp,"#define MAX_PREDICTOR_ENTRY %u\n\n",max_predictor_entry);
        fprintf(_main_fp,"#include <stdio.h>\n\n");
        fprintf(_main_fp,"#include \"branch_predictor.h\"\n\n");
//        fprintf(_main_fp,"#include \"yula_pa_reg_def.h\"\n\n");
        fprintf(_main_fp,"extern long MaiN(int argc,char **argv);\n");
        fprintf(_main_fp,"void MY_iNiT();\n");
        fprintf(_main_fp,"void MY_eXiT();\n");

        fprintf(_main_fp,"int main(int argc,char **argv)\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"      MY_iNiT();\n");
        fprintf(_main_fp,"      atexit(MY_eXiT);\n");
        fprintf(_main_fp,"      MaiN(argc,argv);\n");
        fprintf(_main_fp,"}\n\n");

//      fprintf(_main_fp,"inline void copy_frame (char *copy_to,int that_many)\n");
//        fprintf(_main_fp,"{\n");
//        fprintf(_main_fp,"      int i;\n");
//        fprintf(_main_fp,"      for(i=0;i<that_many;i++) *(char *)(copy_to + i) = global_macro_op[i];\n");
//        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_iNiT()\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"      read_branch_predictor_parms();\n");
        fprintf(_main_fp,"      init_branch_predictor();\n");
        fprintf(_main_fp,"}\n\n");

        fprintf(_main_fp,"void MY_eXiT()\n");
        fprintf(_main_fp,"{\n");
        fprintf(_main_fp,"      FILE *ifp;\n");
        fprintf(_main_fp,"      ifp=fopen(\"branch.acc\",\"w\");\n");
        fprintf(_main_fp,"      if(ifp==NULL)\n");
        fprintf(_main_fp,"      {\n");
        fprintf(_main_fp,"              fprintf(stderr,\"Error open file: branch.acc!\\n\");\n");
        fprintf(_main_fp,"              exit(0);\n");
        fprintf(_main_fp,"      }\n");
        fprintf(_main_fp,"      output_branch_history_entry(ifp);\n");
//        fprintf(_main_fp,"    printf(\"\\nTotal Accesses: \%lu  Total Mispredictions: \%lu\\n\",\n");
        fprintf(_main_fp,"      printf(\"\\nTotal Accesses: ");
        fputc('%',_main_fp);
        fprintf(_main_fp,"lu  Total Mispredictions: ");
        fputc('%',_main_fp);
        fprintf(_main_fp,"lu\\n\",\n");
        fprintf(_main_fp,"             total_accesses, total_miss_predicted);\n");
        fprintf(_main_fp,"}\n\n");

}

void Branch_Profile::close_main_file()
{
        fclose(_main_fp);
}

void Branch_Profile::open_header_file()
{
        _header_fp=fopen(BRANCH_HEADER_FILENAME,"r");
        if(_header_fp==NULL)
        {
                _header_fp=fopen(BRANCH_HEADER_FILENAME,"w");

                if(_header_fp==NULL)
                        assert(0);

                fprintf(_header_fp," extern void MY_BRaNCH_PRoBe (int,int);\n");
        }
}

void Branch_Profile::close_header_file()
{
        fclose(_header_fp);
}

---