ooo_instrumentation.h

Go to the documentation of this file.

#ifndef OOO_INSTRUMENTATION_H_INCLUDED_
#define OOO_INSTRUMENTATION_H_INCLUDED_

#include <iostream>
#include <cstdlib>
#include <unordered_set>
#include <unordered_map>


#include "rose.h"
#include "../segment_graph/combined_data_conflict_table.h"
#include "../segment_graph/prediction_time_advance_table.h"
#include "../segment_graph/prediction_event_notification_table.h"

// Instrumentation of user-defined channels with locks
// (described as item "4. User-defined channel protection"
//  in the RISC TRs up to v050 and the book chapter)
// is redundant (i.e. NOT necessary any more!)
// with the new PCP analysis and "cloning" (DATE'18 paper)!
// 01/14/19, RD.
//
// So we skip instrumentation of 'chnl_scoped_lock' in channels:
//#define RISC_INSTRUMENT_CHNL_SCOPED_LOCK
#ifndef DUMP_TABLE_THRESHOLD
#define DUMP_TABLE_THRESHOLD 42 
#endif

namespace risc {

class Design;

namespace sg {

class DataConflictTable;
class EventConflictTable;
class SegmentGraph;
class TimeAdvanceTable;
}

namespace tools {

class ParseStatus;
}

namespace inst {

class InstrumentationTraversal: public AstSimpleProcessing
{
  public:
    InstrumentationTraversal(
#ifdef RISC_INSTRUMENT_CHNL_SCOPED_LOCK // skip user-channel protection
      SgType*, SgExpression*, SgExpression*,
#endif // RISC_INSTRUMENT_CHNL_SCOPED_LOCK // skip user-channel protection
      SgClassDefinition*, std::map<SgNode*, int>&, std::string );
    virtual void visit(SgNode* astNode);
    bool _psg_off_instrumented;
    SgFunctionDeclaration* first_func_decl_that_contains_wait;
    SgClassDeclaration* first_module_decl;
    std::string design_file_name;
    void hack_instrument_fifo_read(SgFunctionCallExp*, SgExpression*);
  private:
#ifdef RISC_INSTRUMENT_CHNL_SCOPED_LOCK // skip user-channel protection

    SgType* variableType;

    SgExpression* PrimChnlVarRefExp;

    SgExpression* SCChnlVarRefExp;
#endif // RISC_INSTRUMENT_CHNL_SCOPED_LOCK // skip user-channel protection

    SgClassDefinition* SCModuleClassDef;

    std::map<SgNode*, int>& FuncCallExptoID;

    public: std::unordered_set<SgNode*> visited;
    public: std::unordered_map<SgFunctionCallExp*, SgExpression*> map_fifoRead_id;

};

int
risc_link(SgProject* project, risc::tools::ParseStatus* parseStatus, const std::string tool_name);

void
risc_buildCompilerCommandLineOptions(SgFile* file,
                                     std::vector<std::string>& argv,
                                     std::vector<std::string>& compilerCmdLine,
                                     risc::tools::ParseStatus* parseStatus,
                                     const std::string tool_name);

int
risc_compileOutputFile(SgFile* file, risc::tools::ParseStatus* parseStatus, const std::string tool_name);

int
risc_compileOutput(SgProject* project, risc::tools::ParseStatus* parseStatus, const std::string tool_name);

void
risc_unparse(risc::Design &design,
    risc::tools::ParseStatus* parseStatus,
    const std::string tool_name,
    UnparseFormatHelp *unparseFormatHelp = NULL,
    UnparseDelegate* unparseDelegate = NULL);

/*** THIS PATCHING AROUND ROSE LIMITATIONS IS NOT NEEDED ANY MORE
     WITH THE NEW ROSE LIBRARY VERSION 0.9.10.X (RD, 05/30/18)
/ **
 * \fn risc_patch
 * \brief This function patches the static_cast issues in the unparsed
 *        source code file(s)
 * /
void
risc_patch(risc::Design &design,
    risc::tools::ParseStatus* parseStatus,
    const char *methodPattern,
    const char *threadPattern,
    const char *cthreadPattern,
    const std::string tool_name);
***/

int
risc_compile(risc::Design &design, risc::tools::ParseStatus* parseStatus,
    const std::string tool_name);

int
risc_backend(risc::Design &design,
    risc::tools::ParseStatus* parseStatus,
    const std::string tool_name,
    UnparseFormatHelp *unparseFormatHelp = NULL,
    UnparseDelegate* unparseDelegate = NULL);

void
instrumentor(risc::Design &design,
    risc::sg::SegmentGraph &sg,
    risc::sg::DataConflictTable* data_conflict_table,
    risc::sg::EventConflictTable* event_conflict_table,
    risc::sg::TimeAdvanceTable* time_advance_table,
    risc::sg::CombinedDataConflictTable* combined_data_conflict_table,
    risc::sg::PredictionTimeAdvanceTable* prediction_time_advance_table,
    risc::sg::PredictionEventNotificationTable* prediction_event_notification_table,
    risc::sg::PredictionEventNotificationTable* prediction_event_notification_table_no_indirect,
    risc::tools::ParseStatus* parseStatus,
    std::string design_file_name,
    std::vector< std::vector<int> > &psg_seg_id_array,
    std::vector<std::string> &file_names,
    std::vector< std::vector<int> > &channel_seg_id_array,
    std::vector<std::string> &channel_seg_id_array_names
    );

void dump_table_to_file(
    risc::Design &design,
    risc::sg::SegmentGraph &sg,
    risc::sg::DataConflictTable* data_conflict_table,
    risc::sg::EventConflictTable* event_conflict_table,
    risc::sg::TimeAdvanceTable* time_advance_table,
    risc::sg::CombinedDataConflictTable* combined_data_conflict_table,
    risc::sg::PredictionTimeAdvanceTable* prediction_time_advance_table,
    risc::sg::PredictionEventNotificationTable* prediction_event_notification_table,
    risc::sg::PredictionEventNotificationTable* prediction_event_notification_table_no_indirect,
    risc::tools::ParseStatus* parseStatus
    );
    
void instrument_functions_without_definitions(risc::sg::SegmentGraph &sg);


void instrument_port_calls(risc::sg::SegmentGraph &sg);

void instrument_wait_in_channels(risc::sg::SegmentGraph &sg);


void instrument_wait_in_b_transports(risc::sg::SegmentGraph &sg);


void instrument_offset_before_and_after_b_transports(risc::sg::SegmentGraph &sg);
std::string generate_unique_name(std::string var_name);

extern int counter;

} // end of namespace inst

} // end of namespace risc

#endif /* OOO_INSTRUMENTATION_H_INCLUDED_ */

/* ex: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab: */