hc_am.hpp

#pragma once

#include "hc.hpp"
#include <cstddef>
#include <mutex>
#include <initializer_list>

typedef int am_status_t;
#define AM_SUCCESS                           0
// TODO - provide better mapping of HSA error conditions to HC error codes.
#define AM_ERROR_MISC                       -1 
// Flags for am_alloc API:
#define amHostPinned      0x1 
#define amHostNonCoherent 0x1 
#define amHostCoherent    0x2 

namespace hc {

// Info for each pointer in the memtry tracker:
class AmPointerInfo {
public:
    void *      _hostPointer;   
    void *      _devicePointer; 
    void *      _unalignedDevicePointer; 
    std::size_t      _sizeBytes;     
    hc::accelerator _acc;       
    bool        _isInDeviceMem; 
    bool        _isAmManaged;   
    uint64_t    _allocSeqNum;   

    int         _appId;              
    unsigned    _appAllocationFlags; 
    void *      _appPtr;             

    // creates a dummy copy of AmPointerInfo
    AmPointerInfo() :
        _hostPointer(nullptr),
        _devicePointer(nullptr),
        _unalignedDevicePointer(nullptr),
        _sizeBytes(0),
        _isInDeviceMem(false),
        _isAmManaged(false),
        _allocSeqNum(0),
        _appId(-1),
        _appAllocationFlags(0),
        _appPtr(nullptr)  {};

    AmPointerInfo(void *hostPointer, void *devicePointer, void* unalignedDevicePointer, std::size_t sizeBytes, hc::accelerator &acc,  bool isInDeviceMem=false, bool isAmManaged=false) :
        _hostPointer(hostPointer),
        _devicePointer(devicePointer),
        _unalignedDevicePointer(unalignedDevicePointer),
        _sizeBytes(sizeBytes),
        _acc(acc),
        _isInDeviceMem(isInDeviceMem),
        _isAmManaged(isAmManaged),
        _allocSeqNum(0),
        _appId(-1),
        _appAllocationFlags(0),
        _appPtr(nullptr)  {};

    AmPointerInfo & operator= (const AmPointerInfo &other);

};
}



struct hsa_agent_s;

namespace hc {


auto_voidp am_aligned_alloc(std::size_t size, hc::accelerator &acc, unsigned flags, std::size_t alignment = 0);

auto_voidp am_alloc(std::size_t size, hc::accelerator &acc, unsigned flags);

am_status_t am_free(void*  ptr);


am_status_t am_copy(void*  dst, const void*  src, std::size_t size) __attribute__ (( deprecated ("use accelerator_view::copy instead (and note src/dst order reversal)" ))) ;



am_status_t am_memtracker_getinfo(hc::AmPointerInfo *info, const void *ptr);


am_status_t am_memtracker_add(void* ptr, hc::AmPointerInfo &info);


/*
 * Update info for an existing pointer in the memory tracker.
 *
 * @returns AM_ERROR_MISC if pointer is not found in tracker.  
 * @returns AM_SUCCESS if pointer is not found in tracker.  
 *
 * @see am_memtracker_getinfo, am_memtracker_add
 */
am_status_t am_memtracker_update(const void* ptr, int appId, unsigned allocationFlags, void *appPtr=nullptr);


am_status_t am_memtracker_remove(void* ptr);

std::size_t am_memtracker_reset(const hc::accelerator &acc);

void am_memtracker_print(void * targetAddress=nullptr);


void am_memtracker_sizeinfo(const hc::accelerator &acc, std::size_t *deviceMemSize, std::size_t *hostMemSize, std::size_t *userMemSize);


void am_memtracker_update_peers(const hc::accelerator &acc, int peerCnt, hsa_agent_s *agents);

/*
 * Map device memory or hsa allocated host memory pointed to by @p ptr to the peers.
 * 
 * @p ptr pointer which points to device memory or host memory
 * @p num_peer number of peers to map
 * @p peers pointer to peer accelerator list.
 * @return AM_SUCCESS if mapped successfully.
 * @return AM_ERROR_MISC if @p ptr is nullptr or @p num_peer is 0 or @p peers is nullptr.
 * @return AM_ERROR_MISC if @p ptr is not am managed.
 * @return AM_ERROR_MISC if @p ptr is not found in the pointer tracker.
 * @return AM_ERROR_MISC if @p peers incudes a non peer accelerator.
 */
am_status_t am_map_to_peers(void* ptr, std::size_t num_peer, const hc::accelerator* peers); 

/*
 * Locks a host pointer to a vector of agents
 * 
 * @p ac acclerator corresponding to current device
 * @p hostPtr pointer to host memory which should be page-locked
 * @p size size of hostPtr to be page-locked
 * @p visibleAc pointer to hcc accelerators to which the hostPtr should be visible
 * @p numVisibleAc number of elements in visibleAc
 * @return AM_SUCCESS if lock is successfully.
 * @return AM_ERROR_MISC if lock is unsuccessful.
 */
am_status_t am_memory_host_lock(hc::accelerator &ac, void *hostPtr, std::size_t size, hc::accelerator *visibleAc, std::size_t numVisibleAc);

/*
 * Unlock page locked host memory
 * 
 * @p ac current device accelerator
 * @p hostPtr host pointer 
 * @return AM_SUCCESS if unlocked successfully.
 * @return AM_ERROR_MISC if @p hostPtr unlock is un-successful.
 */
am_status_t am_memory_host_unlock(hc::accelerator &ac, void *hostPtr);


}; // namespace hc