Utilities.cpp

#include "Utilities.h"
 
#include <fstream>
#include <map>
#include <mutex>
#include <regex>
#include <sstream>
 
namespace
{
  const std::regex includeStatement("^#include[ ]+[\"<](.*)[\">].*");
 
  struct GPUResourceInfo {
    void*       mAddress;
    uint64_t    mSize;
    uint8_t     mType;
  };
 
#if defined(OSOMP_EnableProfiler)
  std::map<void*, GPUResourceInfo>  gGPUResources;
  std::mutex                        gMutex;
  uint8_t*                          gNextGPUAddress = reinterpret_cast<uint8_t*>(0x1000000000000ULL);
#endif
}
 
void Cogs::RegisterGPUResource(void* handle, size_t size, MemBlockType type, const OsoMPAttribute* attributes, uint32_t noOfAttributes) {
#if defined(OSOMP_EnableProfiler)
  std::lock_guard<std::mutex> lock(gMutex);
 
  assert(gGPUResources.find(handle) == gGPUResources.end());
 
  OsoMP_Allocate(uint8_t(type), gNextGPUAddress, size, attributes, noOfAttributes);
  gGPUResources[handle] = GPUResourceInfo{gNextGPUAddress, size, uint8_t(type)};
  gNextGPUAddress += size;
#else
  (void)handle;
  (void)size;
  (void)type;
  (void)attributes;
  (void)noOfAttributes;
#endif
}
 
void Cogs::RegisterGPUResourceAttributes(void* handle, const OsoMPAttribute* attributes, uint32_t noOfAttributes) {
#if defined(OSOMP_EnableProfiler)
  std::lock_guard<std::mutex> lock(gMutex);
  auto                        i = gGPUResources.find(handle);
 
  if (i != gGPUResources.end()) {
    OsoMP_Attributes(i->second.mAddress, attributes, noOfAttributes);
  }
#else
  (void)handle;
  (void)attributes;
  (void)noOfAttributes;
#endif
}
 
void Cogs::UnregisterGPUResource(void* handle) {
#if defined(OSOMP_EnableProfiler)
  std::lock_guard<std::mutex> lock(gMutex);
  auto                        i = gGPUResources.find(handle);
 
  if (i != gGPUResources.end()) {
    OsoMP_Free(i->second.mType, i->second.mAddress, nullptr, 0);
    gGPUResources.erase(i);
  }
#else
  (void)handle;
#endif
}
 
bool Cogs::Utilities::preprocessFile(IIOHandler * handler, const StringView & filename, ProcessedContent & content)
{
  content.origin = std::string(filename);
 
  std::string source;
  return Utilities::readFile(handler, filename, content);
}
 
bool Cogs::Utilities::preprocessContent(IIOHandler * handler , const StringView & input, ProcessedContent & content)
{
  if (input.empty()) {
    content = ProcessedContent();
    return true;
  }
 
  std::istringstream stream(std::string(input.data(), input.length()));
  return preprocessContent(handler, StringView(), stream, content);
}
 
bool Cogs::Utilities::preprocessContent(IIOHandler * handler, const StringView & input, std::string & content)
{
  if (input == StringView()) return true;
 
        std::istringstream stream(std::string(input.data(), input.length()));
  return preprocessContent(handler, StringView(), stream, content);
}
 
bool Cogs::Utilities::preprocessContent(IIOHandler * handler, const StringView & fileName, std::istream & stream, ProcessedContent & content)
{
  std::string line;
  std::smatch results;
 
  bool contentAdded = false;
  while (stream.good()) {
    std::getline(stream, line);
 
    if (line.size() && line[0] == '#' && std::regex_search(line, results, includeStatement)) {
      if (handler) {
        std::string includeContent;
 
        if (handler->resolveFile(fileName, results[1].str(), includeContent)) {
          if (contentAdded) {
            content.sourceStop.push_back(content.content.size());
            content.sourceName.push_back(std::string(fileName));
            contentAdded = false;
          }
          
          std::istringstream includeStream(includeContent);
          
          if (!preprocessContent(handler, results[1].str(), includeStream, content)) {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      content.content += line;
      content.content += "\n";
      contentAdded = true;
    }
  }
 
  if (contentAdded) {
    content.sourceStop.push_back(content.content.size());
    
    if (fileName.empty()) {
      content.sourceName.push_back("anonymous");
    } else {
      content.sourceName.push_back(std::string(fileName));
    }
  }
 
  return true;
}
 
bool Cogs::Utilities::preprocessContent(IIOHandler * handler, const StringView & fileName, std::istream & stream, std::string & content)
{
  std::string line;
  std::smatch results;
 
  while (stream.good()) {
    std::getline(stream, line);
 
    if (line.size() && line[0] == '#' && std::regex_search(line, results, includeStatement)) {
      if (handler) {
        std::string includeContent;
 
        if (handler->resolveFile(fileName, results[1].str(), includeContent)) {
          if (!preprocessContent(handler, includeContent, content)) {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      content += line;
      content += "\n";
    }
  }
 
  return true;
}
 
bool Cogs::Utilities::readFile(IIOHandler * handler, const StringView & fileName, ProcessedContent & content)
{
  std::string fileContents;
  if (!handler->openFile(fileName, fileContents)) {
    return false;
  }
 
  preprocessContent(handler, fileContents, content);
 
  return true;
}
 
bool Cogs::Utilities::resolveFile(IIOHandler * handler, const StringView & origin, const StringView & fileName, ProcessedContent & content)
{
  auto source = std::string(origin);
  auto path = source.substr(0, source.find_last_of("/") + 1);
 
  if (!readFile(handler, path + std::string(fileName), content)) {
    return false;
  }
 
  return true;
}