rocm-systems/rocclr/runtime/platform/program.cpp

//
// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
//
#include "top.hpp"
#include "device/appprofile.hpp"
#include "platform/program.hpp"
#include "platform/context.hpp"
#include "utils/options.hpp"
#include "utils/libUtils.h"
#include "utils/bif_section_labels.hpp"
#include "acl.h"

#include <cstdlib>  // for malloc
#include <cstring>  // for strcmp
#include <sstream>
#include <fstream>
#include <iostream>
#include <utility>

namespace amd {

Program::~Program() {
  // Destroy all device programs
  deviceprograms_t::const_iterator it, itEnd;
  for (it = devicePrograms_.begin(), itEnd = devicePrograms_.end(); it != itEnd; ++it) {
    delete it->second;
  }

  for (devicebinary_t::const_iterator IT = binary_.begin(), IE = binary_.end(); IT != IE; ++IT) {
    const binary_t& Bin = IT->second;
    if (Bin.first) {
      delete[] Bin.first;
    }
  }

  delete symbolTable_;
  //! @todo Make sure we have destroyed all CPU specific objects
}

const Symbol* Program::findSymbol(const char* kernelName) const {
  symbols_t::const_iterator it = symbolTable_->find(kernelName);
  return (it == symbolTable_->end()) ? NULL : &it->second;
}

cl_int Program::addDeviceProgram(Device& device, const void* image, size_t length,
                                 amd::option::Options* options) {
#if defined(WITH_LIGHTNING_COMPILER)
  // LC binary must be in ELF format
  if (image != NULL && !amd::isElfMagic((const char*)image)) {
    return CL_INVALID_BINARY;
  }
#else   // !defined(WITH_LIGHTNING_COMPILER)
  if (image != NULL &&
      !aclValidateBinaryImage(image, length,
                              isSPIRV_ ? BINARY_TYPE_SPIRV : BINARY_TYPE_ELF | BINARY_TYPE_LLVM)) {
    return CL_INVALID_BINARY;
  }
#endif  // !defined(WITH_LIGHTNING_COMPILER)

  // Check if the device is already associated with this program
  if (deviceList_.find(&device) != deviceList_.end()) {
    return CL_INVALID_VALUE;
  }

  Device& rootDev = device.rootDevice();

  // if the rootDev is already associated with a program
  if (devicePrograms_[&rootDev] != NULL) {
    return CL_SUCCESS;
  }
  bool emptyOptions = false;
  amd::option::Options emptyOpts;
  if (options == NULL) {
    options = &emptyOpts;
    emptyOptions = true;
  }

#if !defined(WITH_LIGHTNING_COMPILER)
  if (image != NULL && length != 0 && aclValidateBinaryImage(image, length, BINARY_TYPE_ELF)) {
    acl_error errorCode;
    aclBinary* binary = aclReadFromMem(image, length, &errorCode);
    if (errorCode != ACL_SUCCESS) {
      return CL_INVALID_BINARY;
    }
    const oclBIFSymbolStruct* symbol = findBIF30SymStruct(symOpenclCompilerOptions);
    assert(symbol && "symbol not found");
    std::string symName = std::string(symbol->str[bif::PRE]) + std::string(symbol->str[bif::POST]);
    size_t symSize = 0;
    const void* opts = aclExtractSymbol(device.compiler(), binary, &symSize, aclCOMMENT,
                                        symName.c_str(), &errorCode);
    // if we have options from binary and input options was not specified
    if (opts != NULL && emptyOptions) {
      std::string sBinOptions = std::string((char*)opts, symSize);
      if (!amd::option::parseAllOptions(sBinOptions, *options)) {
        programLog_ = options->optionsLog();
        LogError("Parsing compilation options from binary failed.");
        return CL_INVALID_COMPILER_OPTIONS;
      }
    }
    options->oVariables->Legacy = isAMDILTarget(*aclutGetTargetInfo(binary));
    aclBinaryFini(binary);
  }
#endif  // !defined(WITH_LIGHTNING_COMPILER)
  options->oVariables->BinaryIsSpirv = isSPIRV_;
  device::Program* program = rootDev.createProgram(options);
  if (program == NULL) {
    return CL_OUT_OF_HOST_MEMORY;
  }

  if (image != NULL) {
    uint8_t* memory = binary(rootDev).first;
    // clone 'binary' (it is owned by the host thread).
    if (memory == NULL) {
      memory = new (std::nothrow) uint8_t[length];
      if (memory == NULL) {
        delete program;
        return CL_OUT_OF_HOST_MEMORY;
      }

      ::memcpy(memory, image, length);

      // Save the original image
      binary_[&rootDev] = std::make_pair(memory, length);
    }

    if (!program->setBinary(reinterpret_cast<char*>(memory), length)) {
      delete program;
      return CL_INVALID_BINARY;
    }

#if defined(WITH_LIGHTNING_COMPILER)
    // load the compiler options from the binary if it is not provided
    std::string sBinOptions = program->compileOptions();
    if (!sBinOptions.empty() && emptyOptions) {
      if (!amd::option::parseAllOptions(sBinOptions, *options)) {
        programLog_ = options->optionsLog();
        LogError("Parsing compilation options from binary failed.");
        return CL_INVALID_COMPILER_OPTIONS;
      }
    }
#endif
  }

  devicePrograms_[&rootDev] = program;

  deviceList_.insert(&device);
  return CL_SUCCESS;
}

device::Program* Program::getDeviceProgram(const Device& device) const {
  deviceprograms_t::const_iterator it = devicePrograms_.find(&device.rootDevice());
  if (it == devicePrograms_.end()) {
    return NULL;
  }
  return it->second;
}

Monitor Program::buildLock_("OCL build program", true);

cl_int Program::compile(const std::vector<Device*>& devices, size_t numHeaders,
                        const std::vector<const Program*>& headerPrograms,
                        const char** headerIncludeNames, const char* options,
                        void(CL_CALLBACK* notifyFptr)(cl_program, void*), void* data,
                        bool optionChangable) {
  ScopedLock sl(buildLock_);

  cl_int retval = CL_SUCCESS;

  // Clear the program object
  clear();

  // Process build options.
  std::string cppstr(options ? options : "");

  // if there is a -ignore-env,  adjust options.
  if (cppstr.size() > 0) {
    // Set the options to be the string after -ignore-env
    size_t pos = cppstr.find("-ignore-env");
    if (pos != std::string::npos) {
      cppstr = cppstr.substr(pos + sizeof("-ignore-env"));
      optionChangable = false;
    }
  }
  option::Options parsedOptions;
  if (!ParseAllOptions(cppstr, parsedOptions, optionChangable)) {
    programLog_ = parsedOptions.optionsLog();
    LogError("Parsing compile options failed.");
    return CL_INVALID_COMPILER_OPTIONS;
  }

  std::vector<const std::string*> headers(numHeaders);
  for (size_t i = 0; i < numHeaders; ++i) {
    const std::string& header = headerPrograms[i]->sourceCode();
    headers[i] = &header;
  }

  // Compile the program programs associated with the given devices.
  std::vector<Device*>::const_iterator it;
  for (it = devices.begin(); it != devices.end(); ++it) {
    device::Program* devProgram = getDeviceProgram(**it);
    if (devProgram == NULL) {
      const binary_t& bin = binary(**it);
      retval = addDeviceProgram(**it, bin.first, bin.second, &parsedOptions);
      if (retval != CL_SUCCESS) {
        return retval;
      }
      devProgram = getDeviceProgram(**it);
    }

    if (devProgram->type() == device::Program::TYPE_INTERMEDIATE || isSPIRV_) {
      continue;
    }
    // We only build a Device-Program once
    if (devProgram->buildStatus() != CL_BUILD_NONE) {
      continue;
    }
    if (sourceCode_.empty()) {
      return CL_INVALID_OPERATION;
    }
    cl_int result =
        devProgram->compile(sourceCode_, headers, headerIncludeNames, options, &parsedOptions);

    // Check if the previous device failed a build
    if ((result != CL_SUCCESS) && (retval != CL_SUCCESS)) {
      retval = CL_INVALID_OPERATION;
    }
    // Update the returned value with a build error
    else if (result != CL_SUCCESS) {
      retval = result;
    }
  }

  if (notifyFptr != NULL) {
    notifyFptr(as_cl(this), data);
  }

  return retval;
}

cl_int Program::link(const std::vector<Device*>& devices, size_t numInputs,
                     const std::vector<Program*>& inputPrograms, const char* options,
                     void(CL_CALLBACK* notifyFptr)(cl_program, void*), void* data,
                     bool optionChangable) {
  ScopedLock sl(buildLock_);
  cl_int retval = CL_SUCCESS;

  if (symbolTable_ == NULL) {
    symbolTable_ = new symbols_t;
    if (symbolTable_ == NULL) {
      return CL_OUT_OF_HOST_MEMORY;
    }
  }

  // Clear the program object
  clear();

  // Process build options.
  std::string cppstr(options ? options : "");

  // if there is a -ignore-env,  adjust options.
  if (cppstr.size() > 0) {
    // Set the options to be the string after -ignore-env
    size_t pos = cppstr.find("-ignore-env");
    if (pos != std::string::npos) {
      cppstr = cppstr.substr(pos + sizeof("-ignore-env"));
      optionChangable = false;
    }
  }
  option::Options parsedOptions;
  if (!ParseAllOptions(cppstr, parsedOptions, optionChangable, true)) {
    programLog_ = parsedOptions.optionsLog();
    LogError("Parsing link options failed.");
    return CL_INVALID_LINKER_OPTIONS;
  }

  // Link the program programs associated with the given devices.
  std::vector<Device*>::const_iterator it;
  for (it = devices.begin(); it != devices.end(); ++it) {
    // find the corresponding device program in each input program
    std::vector<device::Program*> inputDevPrograms(numInputs);
    bool found = false;
    for (size_t i = 0; i < numInputs; ++i) {
      Program& inputProgram = *inputPrograms[i];
      if (inputProgram.isSPIRV_) {
        parsedOptions.oVariables->BinaryIsSpirv = inputProgram.isSPIRV_;
      }
      deviceprograms_t inputDevProgs = inputProgram.devicePrograms();
      deviceprograms_t::const_iterator findIt = inputDevProgs.find(*it);
      if (findIt == inputDevProgs.end()) {
        if (found) break;
        continue;
      }
      inputDevPrograms[i] = findIt->second;
      device::Program::binary_t binary = inputDevPrograms[i]->binary();
// Check the binary's target for the first found device program.
// TODO: Revise these binary's target checks
// and possibly remove them after switching to HSAIL by default.
#if !defined(WITH_LIGHTNING_COMPILER)
      if (!found && binary.first != NULL && binary.second > 0) {
        acl_error errorCode = ACL_SUCCESS;
        void* mem = const_cast<void*>(binary.first);
        aclBinary* aclBin = aclReadFromMem(mem, binary.second, &errorCode);
        if (errorCode != ACL_SUCCESS) {
          LogWarning("Error while linking: Could not read from raw binary.");
          return CL_INVALID_BINARY;
        }
        if (isHSAILTarget(*aclutGetTargetInfo(aclBin))) {
          parsedOptions.oVariables->Frontend = "clang";
        } else if (isAMDILTarget(*aclutGetTargetInfo(aclBin))) {
          parsedOptions.oVariables->Frontend = "edg";
        }
        aclBinaryFini(aclBin);
      }
#endif  // !defined(WITH_LIGHTNING_COMPILER)
      found = true;
    }
    if (inputDevPrograms.size() == 0) {
      continue;
    }
    if (inputDevPrograms.size() < numInputs) {
      return CL_INVALID_VALUE;
    }

    device::Program* devProgram = getDeviceProgram(**it);
    if (devProgram == NULL) {
      const binary_t& bin = binary(**it);
      retval = addDeviceProgram(**it, bin.first, bin.second, &parsedOptions);
      if (retval != CL_SUCCESS) {
        return retval;
      }
      devProgram = getDeviceProgram(**it);
    }

    // We only build a Device-Program once
    if (devProgram->buildStatus() != CL_BUILD_NONE) {
      continue;
    }
    cl_int result = devProgram->link(inputDevPrograms, options, &parsedOptions);

    // Check if the previous device failed a build
    if ((result != CL_SUCCESS) && (retval != CL_SUCCESS)) {
      retval = CL_INVALID_OPERATION;
    }
    // Update the returned value with a build error
    else if (result != CL_SUCCESS) {
      retval = result;
    }
  }

  if (retval != CL_SUCCESS) {
    return retval;
  }

  // Rebuild the symbol table
  deviceprograms_t::iterator sit;
  for (sit = devicePrograms_.begin(); sit != devicePrograms_.end(); ++sit) {
    const Device& device = *sit->first;
    const device::Program& program = *sit->second;

    const device::Program::kernels_t& kernels = program.kernels();
    device::Program::kernels_t::const_iterator kit;
    for (kit = kernels.begin(); kit != kernels.end(); ++kit) {
      const std::string& name = kit->first;
      const device::Kernel* devKernel = kit->second;

      Symbol& symbol = (*symbolTable_)[name];
      if (!symbol.setDeviceKernel(device, devKernel)) {
        retval = CL_LINK_PROGRAM_FAILURE;
      }
    }
  }

  // Create a string with all kernel names from the program
  if (kernelNames_.length() == 0) {
    amd::Program::symbols_t::const_iterator it;
    for (it = symbols().begin(); it != symbols().end(); ++it) {
      if (it != symbols().begin()) {
        kernelNames_.append(1, ';');
      }
      kernelNames_.append(it->first.c_str());
    }
  }

  if (notifyFptr != NULL) {
    notifyFptr(as_cl(this), data);
  }

  return retval;
}

void Program::StubProgramSource(const std::string& app_name) {
  static uint program_counter = 0;
  std::fstream stub_read;
  std::stringstream file_name;
  std::string app_name_no_ext;

  std::size_t length = app_name.rfind(".exe");
  if (length == std::string::npos) {
    length = app_name.size();
  }
  app_name_no_ext.assign(app_name.c_str(), length);

  // Construct a unique file name for the CL program
  file_name << app_name_no_ext << "_program_" << program_counter << ".cl";

  stub_read.open(file_name.str().c_str(), (std::fstream::in | std::fstream::binary));
  // Check if we have OpenCL program
  if (stub_read.is_open()) {
    // Find the stream size
    stub_read.seekg(0, std::fstream::end);
    size_t size = stub_read.tellg();
    stub_read.seekg(0, std::ios::beg);

    char* data = new char[size];
    stub_read.read(data, size);
    stub_read.close();

    sourceCode_.assign(data, size);
    delete[] data;
  } else {
    std::fstream stub_write;
    stub_write.open(file_name.str().c_str(), (std::fstream::out | std::fstream::binary));
    stub_write << sourceCode_;
    stub_write.close();
  }
  program_counter++;
}

cl_int Program::build(const std::vector<Device*>& devices, const char* options,
                      void(CL_CALLBACK* notifyFptr)(cl_program, void*), void* data,
                      bool optionChangable) {
  ScopedLock sl(buildLock_);
  cl_int retval = CL_SUCCESS;

  if (symbolTable_ == NULL) {
    symbolTable_ = new symbols_t;
    if (symbolTable_ == NULL) {
      return CL_OUT_OF_HOST_MEMORY;
    }
  }

  if (OCL_STUB_PROGRAMS && !sourceCode_.empty()) {
    // The app name should be the samme for all device
    StubProgramSource(devices[0]->appProfile()->appFileName());
  }

  // Clear the program object
  clear();

  // Process build options.
  std::string cppstr(options ? options : "");

  // if there is a -ignore-env,  adjust options.
  if (cppstr.size() > 0) {
    // Set the options to be the string after -ignore-env
    size_t pos = cppstr.find("-ignore-env");
    if (pos != std::string::npos) {
      cppstr = cppstr.substr(pos + sizeof("-ignore-env"));
      optionChangable = false;
    }
  }
  option::Options parsedOptions;
  if (!ParseAllOptions(cppstr, parsedOptions, optionChangable)) {
    programLog_ = parsedOptions.optionsLog();
    LogError("Parsing compile options failed.");
    return CL_INVALID_COMPILER_OPTIONS;
  }

  // Build the program programs associated with the given devices.
  std::vector<Device*>::const_iterator it;
  for (it = devices.begin(); it != devices.end(); ++it) {
    device::Program* devProgram = getDeviceProgram(**it);
    if (devProgram == NULL) {
      const binary_t& bin = binary(**it);
      if (sourceCode_.empty() && (bin.first == NULL)) {
        retval = false;
        continue;
      }
      retval = addDeviceProgram(**it, bin.first, bin.second, &parsedOptions);
      if (retval != CL_SUCCESS) {
        return retval;
      }
      devProgram = getDeviceProgram(**it);
    }

    parsedOptions.oVariables->AssumeAlias = true;

    // We only build a Device-Program once
    if (devProgram->buildStatus() != CL_BUILD_NONE) {
      continue;
    }
    cl_int result = devProgram->build(sourceCode_, options, &parsedOptions);

    // Check if the previous device failed a build
    if ((result != CL_SUCCESS) && (retval != CL_SUCCESS)) {
      retval = CL_INVALID_OPERATION;
    }
    // Update the returned value with a build error
    else if (result != CL_SUCCESS) {
      retval = result;
    }
  }

  if (retval != CL_SUCCESS) {
    return retval;
  }

  // Rebuild the symbol table
  deviceprograms_t::iterator sit;
  for (sit = devicePrograms_.begin(); sit != devicePrograms_.end(); ++sit) {
    const Device& device = *sit->first;
    const device::Program& program = *sit->second;

    const device::Program::kernels_t& kernels = program.kernels();
    device::Program::kernels_t::const_iterator kit;
    for (kit = kernels.begin(); kit != kernels.end(); ++kit) {
      const std::string& name = kit->first;
      const device::Kernel* devKernel = kit->second;

      Symbol& symbol = (*symbolTable_)[name];
      if (!symbol.setDeviceKernel(device, devKernel)) {
        retval = CL_BUILD_PROGRAM_FAILURE;
      }
    }
  }

  // Create a string with all kernel names from the program
  if (kernelNames_.length() == 0) {
    amd::Program::symbols_t::const_iterator it;
    for (it = symbols().begin(); it != symbols().end(); ++it) {
      if (it != symbols().begin()) {
        kernelNames_.append(1, ';');
      }
      kernelNames_.append(it->first.c_str());
    }
  }

  if (notifyFptr != NULL) {
    notifyFptr(as_cl(this), data);
  }

  return retval;
}

void Program::clear() {
  deviceprograms_t::iterator sit;

  // Destroy old programs if we have any
  for (sit = devicePrograms_.begin(); sit != devicePrograms_.end(); ++sit) {
    // Destroy device program
    delete sit->second;
  }

  devicePrograms_.clear();
  deviceList_.clear();
  if (symbolTable_) symbolTable_->clear();
  kernelNames_.clear();
}

int Program::GetOclCVersion(const char* clVer) {
  // default version
  int version = 12;
  if (clVer == NULL) {
    return version;
  }
  std::string clStd(clVer);
  if (clStd.size() != 5) {
    return version;
  }
  clStd.erase(0, 2);
  clStd.erase(1, 1);
  return std::stoi(clStd);
}

bool Program::ParseAllOptions(const std::string& options, option::Options& parsedOptions,
                              bool optionChangable, bool linkOptsOnly) {
  std::string allOpts = options;
  if (optionChangable) {
    if (linkOptsOnly) {
      if (AMD_OCL_LINK_OPTIONS != NULL) {
        allOpts.append(" ");
        allOpts.append(AMD_OCL_LINK_OPTIONS);
      }
      if (AMD_OCL_LINK_OPTIONS_APPEND != NULL) {
        allOpts.append(" ");
        allOpts.append(AMD_OCL_LINK_OPTIONS_APPEND);
      }
    } else {
      if (AMD_OCL_BUILD_OPTIONS != NULL) {
        allOpts.append(" ");
        allOpts.append(AMD_OCL_BUILD_OPTIONS);
      }
      if (!Device::appProfile()->GetBuildOptsAppend().empty()) {
        allOpts.append(" ");
        allOpts.append(Device::appProfile()->GetBuildOptsAppend());
      }
      if (AMD_OCL_BUILD_OPTIONS_APPEND != NULL) {
        allOpts.append(" ");
        allOpts.append(AMD_OCL_BUILD_OPTIONS_APPEND);
      }
    }
  }
  return amd::option::parseAllOptions(allOpts, parsedOptions, linkOptsOnly);
}

bool Symbol::setDeviceKernel(const Device& device, const device::Kernel* func, bool noAlias) {
  // FIXME_lmoriche: check that the signatures are compatible
  if (deviceKernels_.size() == 0 || device.type() == CL_DEVICE_TYPE_CPU) {
    signature_ = func->signature();
  }

  if (noAlias) {
    deviceKernels_[&device] = func;
  } else {
    devKernelsNoOpt_[&device] = func;
  }
  return true;
}

const device::Kernel* Symbol::getDeviceKernel(const Device& device, bool noAlias) const {
  const devicekernels_t* devKernels = (noAlias) ? &deviceKernels_ : &devKernelsNoOpt_;
  devicekernels_t::const_iterator itEnd = devKernels->end();
  devicekernels_t::const_iterator it = devKernels->find(&device);
  if (it != itEnd) {
    return it->second;
  }

  for (it = devKernels->begin(); it != itEnd; ++it) {
    if (it->first->isAncestor(&device)) {
      return it->second;
    }
  }

  return NULL;
}

}  // namespace amd