Moved visc-rt from parent directory into projects

hpvm/projects/visc-rt/CMakeLists.txt

+add_custom_target(visc-rt ALL)
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/deviceStatusSwitchIntervals.txt
+    ${CMAKE_CURRENT_BINARY_DIR}/deviceStatusSwitchIntervals.txt
+  DEPENDS deviceStatusSwitchIntervals.txt
+  COMMENT "Copying deviceStatusSwitchIntervals.txt")
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/device_abstraction.h
+    ${CMAKE_CURRENT_BINARY_DIR}/device_abstraction.h
+  DEPENDS device_abstraction.h
+  COMMENT "Copying device_abstraction.h")
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/policy.h
+    ${CMAKE_CURRENT_BINARY_DIR}/policy.h
+  DEPENDS policy.h
+  COMMENT "Copying policy.h")
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/visc-rt.h
+    ${CMAKE_CURRENT_BINARY_DIR}/visc-rt.h
+  DEPENDS visc-rt.h
+  COMMENT "Copying visc-rt.h")
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/visc-rt.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/visc-rt.cpp
+  DEPENDS visc-rt.cpp
+  COMMENT "Copying visc-rt.cpp")
+add_custom_command(
+  TARGET visc-rt PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${CMAKE_CURRENT_SOURCE_DIR}/makefile
+    ${CMAKE_CURRENT_BINARY_DIR}/makefile
+  DEPENDS makefile
+  COMMENT "Copying makefile")

hpvm/projects/visc-rt/deviceStatusSwitchIntervals.txt

+10
+10 15 10 16 15 30 15 25 20 15

hpvm/projects/visc-rt/device_abstraction.h

+#ifndef __DEVICE_ABSTRACTION__
+#define __DEVICE_ABSTRACTION__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <time.h>
+#include <thread>
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+#define MIN_INTERVAL 2
+#define MAX_INTERVAL 8
+#define NUM_INTERVALS 10
+
+// Device status variable: true if the device is available for use
+volatile bool deviceStatus = true;
+// Intervals at which to change the device status
+std::vector<unsigned> Intervals;
+
+// Set to true when program execution ends and so we can end the device
+// simulation
+volatile bool executionEnd = false;
+
+
+void initializeDeviceStatusIntervals() {
+
+  unsigned sz = 0;
+  unsigned tmp = 0;
+
+  const char *fn =
+    "/home/kotsifa2/HPVM/hpvm/build/projects/visc-rt/deviceStatusSwitchIntervals.txt";
+  std::ifstream infile;
+  infile.open(fn);
+  if (!infile.is_open()) {
+    std::cout << "Failed to open " << fn << " for reading\n";
+    return;
+  }
+  infile >> sz;
+
+  if (sz) {
+    // We have data. Read them into the vector
+    for (unsigned i = 0; i < sz; i++) {
+      infile >> tmp;
+      Intervals.push_back(tmp);
+    }
+    infile.close();
+  } else {
+    // We have no data. Create random data and write them into the file
+    infile.close();
+    std::ofstream outfile;
+    outfile.open(fn);
+    if (!outfile.is_open()) {
+      std::cout << "Failed to open " << fn << " for writing\n";
+      return;
+    }
+    sz = 1 + rand()%NUM_INTERVALS;
+    outfile << sz; 
+    for (unsigned i = 0; i < sz; i++) {
+      Intervals.push_back(MIN_INTERVAL + rand()%(MAX_INTERVAL - MIN_INTERVAL));
+      outfile << Intervals[i];
+    }
+    outfile.close();
+  }
+
+  return;
+}
+
+void updateDeviceStatus() {
+
+  unsigned i = 0;
+  while (!executionEnd) {
+    std::this_thread::sleep_for (std::chrono::seconds(Intervals[i]));
+    deviceStatus = !deviceStatus;
+    std::cout << "Changed device status to " << deviceStatus << "\n";
+    i = (i+1) % Intervals.size();
+  }
+
+}
+
+#endif // __DEVICE_ABSTRACTION__

hpvm/projects/visc-rt/makefile

+#LLVM_SRC_ROOT = ../../../llvm
+LLVM_BUILD_ROOT = ${LLVM_SRC_ROOT}/../build/
+
+OPENCL_INC_PATH = /opt/intel/opencl-sdk/include
+
+ifeq ($(NUM_CORES),)
+  NUM_CORES=8
+endif
+
+CPP_FLAGS = -I $(LLVM_SRC_ROOT)/include -I $(LLVM_BUILD_ROOT)/include -I $(OPENCL_INC_PATH) -std=c++11 -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS
+TARGET:=visc-rt
+
+LLVM_CC:=$(LLVM_BUILD_ROOT)/bin/clang
+LLVM_CXX:=$(LLVM_BUILD_ROOT)/bin/clang++
+
+OPTS =
+
+ifeq ($(DEBUG),1)
+  OPTS+=-DDEBUG_BUILD
+endif
+
+all: $(TARGET:%=%.ll)
+
+$(TARGET:%=%.ll):%.ll:%.cpp %.h
+	$(LLVM_CXX) -DNUM_CORES=$(NUM_CORES) -O3 -S -emit-llvm $(CPP_FLAGS) $(OPTS) $< -o $@
+
+clean :
+	rm -f $(TARGET).ll

hpvm/projects/visc-rt/policy.h

+#ifndef __POLICY__
+#define __POLICY__
+
+#include <string>
+#include "device_abstraction.h"
+
+ /************************* Policies *************************************/
+class Policy {
+  public:
+    virtual int getVersion(const char *, int64_t) = 0;
+    virtual ~Policy() {};
+};
+
+class NodePolicy : public Policy {
+  virtual int getVersion(const char *name, int64_t it) override {
+    std::string s(name);
+    //std::string NodeNames[1] = { "_Z9mysgemmNTPfiS_iS_iiff_clonedInternal_level2_cloned" };
+    std::string NodeNames[] = {
+      "WrapperGaussianSmoothing_cloned",
+      "WrapperlaplacianEstimate_cloned",
+      "WrapperComputeZeroCrossings_cloned",
+      "WrapperComputeGradient_cloned",
+      "WrapperComputeMaxGradient_cloned",
+      "WrapperRejectZeroCrossings_cloned",
+    };
+    //if (!s.compare(NodeNames[4])) {
+    //  std::cout << s << ": CPU" << "\n";
+    //  return 0;
+    //}
+    return 2;
+  }
+};
+
+class IterationPolicy : public Policy {
+  virtual int getVersion(const char *name, int64_t it) override {
+    if ((it % 10 == 0) || (it % 10 == 1))
+      return 0;
+    else
+      return 2;
+  }
+};
+
+class DeviceStatusPolicy : public Policy {
+  virtual int getVersion(const char *name, int64_t it) override {
+    if (deviceStatus) {
+      //std::cout << "Returning GPU\n";
+      return 2;
+    }
+    else {
+      //std::cout << "Returning CPU\n";
+      return 0;
+    }
+  }
+};
+
+/* ------------------------------------------------------------------------- */
+// Added for the CFAR interactive policy demo.
+
+class InteractivePolicy : public Policy {
+private:
+  // 0 :for CPU, 1 for GPU, 2 for Vector
+  unsigned int userTargetDeviceChoice;
+  // Used to end thread execution
+  bool end;
+  // Thread that will update userTargetDeviceChoice
+  std::thread userTargetDeviceChoiceThread;
+  // Thread function
+  void updateUserTargetChoice() {
+    while (!end) {
+      std::cout << "Select target device (0 for CPU, 1 fpr GPU): ";
+      std::cin >> userTargetDeviceChoice;
+      if (userTargetDeviceChoice > 1) {
+        std::cout << "Invalid target device. Selecting GPU instead.\n";
+        userTargetDeviceChoice = 1;
+      }
+    }
+  }
+
+public:
+  // Inherited method, erquired for every policy object
+  virtual int getVersion(const char *name, int64_t it) {
+    return userTargetDeviceChoice;
+  }
+
+  InteractivePolicy() {
+    userTargetDeviceChoice = 1;
+    end = false;
+    userTargetDeviceChoiceThread =
+      std::thread(&InteractivePolicy::updateUserTargetChoice, this);
+  }
+
+  ~InteractivePolicy() {
+    end = true;
+    userTargetDeviceChoiceThread.join(); 
+  }
+};
+
+#endif // __POLICY__

hpvm/projects/visc-rt/visc-rt.h

+/*
+ *
+ * (c) 2010 The Board of Trustees of the University of Illinois.
+ */
+#ifndef VISC_RT_HEADER
+#define VISC_RT_HEADER
+
+#include <iostream>
+#include <map>
+#include <ctime>
+#include <vector>
+#include <pthread.h>
+#include <string>
+//#include <condition_variable>
+
+#include "../include/SupportVISC/VISCHint.h"
+#include "../include/SupportVISC/VISCTimer.h"
+#include "device_abstraction.h"
+#include "policy.h"
+
+#ifndef DEBUG_BUILD
+#define DEBUG(s) {}
+#else
+#define DEBUG(s) s
+#endif
+
+
+
+using namespace std;
+
+extern "C" {
+
+/************************* Policies *************************************/
+
+void llvm_visc_policy_init();
+void llvm_visc_policy_clear();
+int llvm_visc_policy_getVersion(const char *, int64_t);
+
+/******************** Device Abstraction ********************************/
+void llvm_visc_deviceAbstraction_start();
+void llvm_visc_deviceAbstraction_end();
+void llvm_visc_deviceAbstraction_waitOnDeviceStatus();
+
+/********************* DFG Depth Stack **********************************/
+class DFGDepth {
+  private:
+    unsigned numDim;
+    unsigned dimLimit[3];
+    unsigned dimInstance[3];
+  public:
+    DFGDepth() {}
+    DFGDepth(unsigned n, unsigned dimX = 0, unsigned iX = 0, unsigned dimY = 0, unsigned iY = 0,
+        unsigned dimZ = 0, unsigned iZ = 0) {
+      assert(n <= 3 && "Error! More than 3 dimensions not supported");
+      numDim = n;
+      dimLimit[0] = dimX;
+      dimLimit[1] = dimY;
+      dimLimit[2] = dimZ;
+      dimInstance[0] = iX;
+      dimInstance[1] = iY;
+      dimInstance[2] = iZ;
+    }
+    unsigned getDimLimit(unsigned dim) {
+      assert(dim <= numDim && "Error! Requested dimension limit is not specified");
+      return dimLimit[dim];
+    }
+
+    unsigned getDimInstance(unsigned dim) {
+      assert(dim <= numDim && "Error! Requested dimension instance is not specified");
+      return dimInstance[dim];
+    }
+
+    unsigned getNumDim() {
+      return numDim;
+    }
+};
+
+void llvm_visc_x86_dstack_push(unsigned n, uint64_t limitX = 0, uint64_t iX = 0,
+    uint64_t limitY = 0, uint64_t iY = 0, uint64_t limitZ = 0, uint64_t iZ = 0);
+void llvm_visc_x86_dstack_pop();
+uint64_t llvm_visc_x86_getDimLimit(unsigned level, unsigned dim);
+uint64_t llvm_visc_x86_getDimInstance(unsigned level, unsigned dim);
+
+
+/********************* Memory Tracker **********************************/
+class MemTrackerEntry {
+public:
+  enum Location {HOST, DEVICE};
+  private:
+    size_t size;
+    Location loc;
+    void* addr;
+    void* Context;
+
+  public:
+    MemTrackerEntry(size_t _size, Location _loc, void* _addr, void* _Context):
+      size(_size), loc(_loc), addr(_addr), Context(_Context) {
+    }
+
+    size_t getSize() {
+      return size;
+    }
+
+    Location getLocation() {
+      return loc;
+    }
+
+    void* getAddress() {
+      return addr;
+    }
+
+    void* getContext() {
+      return Context;
+    }
+
+    void update(Location _loc, void* _addr, void* _Context = NULL) {
+      loc = _loc;
+      addr = _addr;
+      Context = _Context;
+    }
+
+    void print() {
+      cout << "Size = " << size << "\tLocation = " << loc << "\tAddress = " << addr << "\tContext = " << Context;
+    }
+};
+
+
+class MemTracker {
+
+private:
+  std::map<void*, MemTrackerEntry*> Table;
+
+public:
+  MemTracker() {
+  }
+
+  bool insert(void* ID, size_t size, MemTrackerEntry::Location loc, void* addr, void* Context = NULL) {
+    MemTrackerEntry* MTE = new MemTrackerEntry(size, loc, addr, Context);
+    Table.insert(std::pair<void*, MemTrackerEntry*>(ID, MTE));
+    return MTE != NULL;
+  }
+
+  MemTrackerEntry* lookup(void* ID) {
+    if(Table.count(ID) == 0)
+      return NULL;
+    return Table[ID];
+  }
+
+  void remove(void* ID) {
+    MemTrackerEntry* MTE = Table[ID];
+    free(MTE);
+    Table.erase(ID);
+  }
+
+  void print() {
+    cout << "Printing Table ... Size = " << Table.size() << flush << "\n";
+    for(auto& Entry: Table) {
+      cout << Entry.first << ":\t" ;
+      Entry.second->print();
+      cout << flush << "\n";
+    }
+  }
+
+};
+
+void llvm_visc_track_mem(void*, size_t);
+void llvm_visc_untrack_mem(void*);
+void* llvm_visc_request_mem(void*, size_t);
+
+/*********************** OPENCL & PTHREAD API **************************/
+void* llvm_visc_x86_launch(void* (void*), void*);
+void llvm_visc_x86_wait(void*);
+void* llvm_visc_ocl_initContext(enum visc::Target);
+
+void* llvm_visc_x86_argument_ptr(void*, size_t);
+
+void llvm_visc_ocl_clearContext(void*);
+void llvm_visc_ocl_argument_shared(void*, int, size_t);
+void llvm_visc_ocl_argument_scalar(void*, void*, int, size_t);
+void* llvm_visc_ocl_argument_ptr(void*, void*, int, size_t, bool, bool);
+void* llvm_visc_ocl_output_ptr(void*, int, size_t);
+void llvm_visc_ocl_free(void*);
+void* llvm_visc_ocl_getOutput(void*, void*, void*, size_t);
+void* llvm_visc_ocl_executeNode(void*, unsigned, const size_t*, const size_t*);
+void* llvm_visc_ocl_launch(const char*, const char*);
+void llvm_visc_ocl_wait(void*);
+
+void llvm_visc_switchToTimer(void** timerSet, enum visc_TimerID);
+void llvm_visc_printTimerSet(void** timerSet, char* timerName = NULL);
+void* llvm_visc_initializeTimerSet();
+
+}
+
+/*************************** Pipeline API ******************************/
+// Circular Buffer class
+unsigned counter = 0;
+template <class ElementType>
+class CircularBuffer {
+private:
+    int numElements;
+    int bufferSize;
+    int Head;
+    int Tail;
+    pthread_mutex_t mtx;
+    pthread_cond_t cv;
+    vector<ElementType> buffer;
+    std::string name;
+    unsigned ID;
+
+public:
+    CircularBuffer(int maxElements, std::string _name =  "ANON") {
+        ID = counter;
+        Head = 0;
+        Tail = 0;
+        numElements = 0;
+        name = _name;
+        bufferSize = maxElements+1;
+        buffer.reserve(bufferSize);
+        pthread_mutex_init(&mtx, NULL);
+        pthread_cond_init(&cv, NULL);
+        counter++;
+
+    }
+
+    bool push(ElementType E);
+    ElementType pop();
+
+};
+
+template <class ElementType>
+bool CircularBuffer<ElementType>::push(ElementType E) {
+    //DEBUG(cout << name << " Buffer[" << ID << "]: Push " << E << flush << "\n");
+    //unique_lock<mutex> lk(mtx);
+    pthread_mutex_lock(&mtx);
+    if((Head +1) % bufferSize == Tail) {
+        //DEBUG(cout << name << " Buffer[" << ID << "]: Push going to sleep ...\n");
+        //cv.wait(lk);
+        pthread_cond_wait(&cv, &mtx);
+        //DEBUG(cout << name << " Buffer[" << ID << "]: Push woke up\n");
+    }
+    buffer[Head] = E;
+    Head = (Head+1) % bufferSize;
+    numElements++;
+    //DEBUG(cout << name << " Buffer[" << ID << "]: Total Elements = " << numElements << flush << "\n");
+    //lk.unlock();
+    pthread_mutex_unlock(&mtx);
+    //cv.notify_one();
+    pthread_cond_signal(&cv);
+    return true;
+}
+
+template <class ElementType>
+ElementType CircularBuffer<ElementType>::pop() {
+    //unique_lock<mutex> lk(mtx);
+    //DEBUG(cout << name << " Buffer[" << ID << "]: Pop\n");
+    pthread_mutex_lock(&mtx);
+    if(Tail == Head) {
+        //DEBUG(cout << name << " Buffer[" << ID << "]: Pop going to sleep ...\n");
+        //cv.wait(lk);
+        pthread_cond_wait(&cv, &mtx);
+        //DEBUG(cout << name << " Buffer[" << ID << "]: Pop woke up\n");
+    }
+    ElementType E = buffer[Tail];
+    Tail = (Tail + 1) % bufferSize;
+    numElements--;
+    //DEBUG(cout << name << " Buffer[" << ID << "]: Total Elements = " << numElements << flush << "\n");
+    //lk.unlock();
+    pthread_mutex_unlock(&mtx);
+    //cv.notify_one();
+    pthread_cond_signal(&cv);
+    return E;
+}
+
+extern "C" {
+// Functions to push and pop values from pipeline buffers
+uint64_t llvm_visc_bufferPop(void*);
+void llvm_visc_bufferPush(void*, uint64_t);
+
+// Functions to create and destroy buffers
+void* llvm_visc_createBindInBuffer(void*, uint64_t, unsigned);
+void* llvm_visc_createBindOutBuffer(void*, uint64_t);
+void* llvm_visc_createEdgeBuffer(void*, uint64_t);
+void* llvm_visc_createLastInputBuffer(void*, uint64_t);
+
+void llvm_visc_freeBuffers(void*);
+
+// Functions to create and destroy threads
+void llvm_visc_createThread(void* graphID, void*(*Func)(void*), void*);
+void llvm_visc_freeThreads(void*);
+
+// Launch API for a streaming graph.
+// Arguments:
+// (1) Launch Function: void* (void*, void*)
+// (2) Push Function:   void (void*, std::vector<uint64_t>**, unsgined)
+// (3) Pop Function:    void* (std::vector<uint64_t>**, unsigned)
+void* llvm_visc_streamLaunch(void(*LaunchFunc)(void*, void*), void*);
+void llvm_visc_streamPush(void* graphID, void* args);
+void* llvm_visc_streamPop(void* graphID);
+void llvm_visc_streamWait(void* graphID);
+
+}
+
+#endif //VISC_RT_HEADER