platform.h

Go to the documentation of this file.

// Copyright 2018 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <dlfcn.h>
#include <memory>
#include <string>
#include <cassert>
 
#include "fletcher/status.h"
 
#if defined(__MACH__)
#define DYLIB_EXT ".dylib"
#else
#define DYLIB_EXT ".so"
#endif
 
namespace fletcher {
 
class Platform {
 public:
  ~Platform() {
    if (!terminated) {
      platformTerminate(terminate_data);
    }
  }
 
  static Status Make(const std::string &name, std::shared_ptr<Platform> *platform_out, bool quiet = true);
 
  static Status Make(std::shared_ptr<Platform> *platform_out, bool quiet = true);
 
  std::string name();
 
  Status MmioToString(std::string *str, uint64_t start, uint64_t stop, bool quiet = false);
 
  [[nodiscard]] Status Init() const { return Status(platformInit(init_data)); }
 
  [[nodiscard]] Status WriteMMIO(uint64_t offset, uint32_t value) const { return Status(platformWriteMMIO(offset, value)); }
 
  Status ReadMMIO(uint64_t offset, uint32_t *value) const { return Status(platformReadMMIO(offset, value)); }
 
  Status ReadMMIO64(uint64_t offset, uint64_t *value);
 
  Status DeviceMalloc(da_t *device_address, const int64_t size) const {
    return Status(platformDeviceMalloc(device_address, size));
  }
 
  [[nodiscard]] Status DeviceFree(const da_t device_address) const { return Status(platformDeviceFree(device_address)); }
 
  Status CopyHostToDevice(const uint8_t *host_source, const da_t device_destination, const int64_t size) const {
    return Status(platformCopyHostToDevice(host_source, device_destination, size));
  }
 
  Status CopyDeviceToHost(const da_t device_source, uint8_t *host_destination, const int64_t size) const {
    return Status(platformCopyDeviceToHost(device_source, host_destination, size));
  }
 
  Status PrepareHostBuffer(const uint8_t *host_source, da_t *device_destination, int64_t size, bool *alloced) const {
    assert(platformPrepareHostBuffer != nullptr);
    int ll_alloced = 0;
    auto stat = platformPrepareHostBuffer(host_source, device_destination, size, &ll_alloced);
    *alloced = ll_alloced == 1;
    return Status(stat);
  }
 
  Status CacheHostBuffer(const uint8_t *host_source, da_t *device_destination, const int64_t size) const {
    assert(platformCacheHostBuffer != nullptr);
    return Status(platformCacheHostBuffer(host_source, device_destination, size));
  }
 
  Status Terminate() {
    assert(platformTerminate != nullptr);
    terminated = true;
    return Status(platformTerminate(terminate_data));
  }
 
  void *init_data = nullptr;
  void *terminate_data = nullptr;
 
 private:
  // Functions to be linked:
  fstatus_t (*platformGetName)(char *name, size_t size) = nullptr;
  fstatus_t (*platformInit)(void *arg) = nullptr;
  fstatus_t (*platformWriteMMIO)(uint64_t offset, uint32_t value) = nullptr;
  fstatus_t (*platformReadMMIO)(uint64_t offset, uint32_t *value) = nullptr;
  fstatus_t (*platformDeviceMalloc)(da_t *device_address, int64_t size) = nullptr;
  fstatus_t (*platformDeviceFree)(da_t device_address) = nullptr;
  fstatus_t (*platformCopyHostToDevice)(const uint8_t *host_source, da_t device_destination, int64_t size) = nullptr;
  fstatus_t (*platformCopyDeviceToHost)(const da_t device_source, uint8_t *host_destination, int64_t size) = nullptr;
  fstatus_t (*platformPrepareHostBuffer)(const uint8_t *host_source,
                                         da_t *device_destination,
                                         int64_t size,
                                         int *alloced) = nullptr;
  fstatus_t (*platformCacheHostBuffer)(const uint8_t *host_source, da_t *device_destination, int64_t size) = nullptr;
  fstatus_t (*platformTerminate)(void *arg) = nullptr;
 
  Status Link(void *handle, bool quiet = true);
 
  bool terminated = false;
};
 
}  // namespace fletcher