Skip to content
Snippets Groups Projects
Commit 21496d80 authored by Akash Kothari's avatar Akash Kothari :speech_balloon:
Browse files

Remove redundant visc-rt

parent 16c51f8f
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
hpvm/visc-rt/CMakeLists.txt deleted 100644 → 0
+ 0
− 43
View file @ 16c51f8f
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/visc-rt/deviceStatusSwitchIntervals.txt deleted 100644 → 0
+ 0
− 2
View file @ 16c51f8f
10
10 15 10 16 15 30 15 25 20 15
hpvm/visc-rt/device_abstraction.h deleted 100644 → 0
+ 0
− 82
View file @ 16c51f8f
#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/visc-rt/makefile deleted 100644 → 0
+ 0
− 28
View file @ 16c51f8f
#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/visc-rt/policy.h deleted 100644 → 0
+ 0
− 98
View file @ 16c51f8f
#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/visc-rt/visc-rt.cpp deleted 100644 → 0
+ 0
− 1645
View file @ 16c51f8f
This diff is collapsed.
hpvm/visc-rt/visc-rt.h deleted 100644 → 0
+ 0
− 303
View file @ 16c51f8f
/*
*
* (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
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment