SWDEV-285333 - Introduce Address sanitizer hostcall service

Change-Id: Id29aacd09d0a9934a027446c57c7095804e1a454

rocclr/device/devhostcall.hpp

@@ -22,9 +22,14 @@
 
 #include "top.hpp"
 #include "device/device.hpp"
-
+#include "device/devhcmessages.hpp"
 #include <cstddef>
 
+#if defined(__clang__)
+#if __has_feature(address_sanitizer)
+#include "device/devurilocator.hpp"
+#endif
+#endif
 /** \file Support for invoking host services from the device.
  *
  *  A hostcall is a fixed-size request generated by a kernel running
@@ -79,3 +84,94 @@ uint32_t getHostcallBufferAlignment(void);
 
 bool enableHostcalls(const amd::Device& dev, void* buffer, uint32_t numPackets);
 void disableHostcalls(void* buffer);
+
+enum SignalValue { SIGNAL_DONE = 0, SIGNAL_INIT = 1 };
+
+/** \brief Packet payload
+ *
+ *  Contains 64 slots of 8 ulongs each, one for each workitem in the
+ *  wave. A slot with index \c i contains valid data if the
+ *  corresponding bit in PacketHeader::activemask is set.
+ */
+struct Payload {
+  uint64_t slots[64][8];
+};
+
+/** Packet header */
+struct PacketHeader {
+  /** Tagged pointer to the next packet in an intrusive stack */
+  uint64_t next_;
+  /** Bitmask that represents payload slots with valid data */
+  uint64_t activemask_;
+  /** Service ID requested by the wave */
+  uint32_t service_;
+  /** Control bits.
+   *  \li 0: \c READY flag. Indicates packet awaiting a host response.
+   */
+  std::atomic<uint32_t> control_;
+};
+
+static_assert(std::is_standard_layout<PacketHeader>::value,
+              "the hostcall packet must be useable from other languages");
+
+/** Field offsets in the packet control field */
+enum ControlOffset {
+  CONTROL_OFFSET_READY_FLAG = 0,
+  CONTROL_OFFSET_RESERVED0 = 1,
+};
+
+/** Field widths in the packet control field */
+enum ControlWidth {
+  CONTROL_WIDTH_READY_FLAG = 1,
+  CONTROL_WIDTH_RESERVED0 = 31,
+};
+
+/** \brief Shared buffer submitting hostcall requests.
+ *
+ *  Holds hostcall packets requested by all kernels executing on the
+ *  same device queue. Each hostcall buffer is associated with at most
+ *  one device queue.
+ *
+ *  Packets in the buffer are accessed using 64-bit tagged pointers to mitigate
+ *  the ABA problem in lock-free stacks. The index_mask is used to extract the
+ *  lower bits of the pointer, which form the index into the packet array. The
+ *  remaining higher bits define a tag that is incremented on every pop from a
+ *  stack.
+ */
+class HostcallBuffer {
+  /** Array of packet headers */
+  PacketHeader* headers_;
+  /** Array of packet payloads */
+  Payload* payloads_;
+  /** Signal used by kernels to indicate new work */
+  void* doorbell_;
+  /** Stack of free packets. Uses tagged pointers. */
+  uint64_t free_stack_;
+  /** Stack of ready packets. Uses tagged pointers */
+  std::atomic<uint64_t> ready_stack_;
+  /** Mask for accessing the packet index in the tagged pointer. */
+  uint64_t index_mask_;
+  /** Some services need a device**/
+  const  amd::Device* device_;
+
+  PacketHeader* getHeader(uint64_t ptr) const;
+  Payload* getPayload(uint64_t ptr) const;
+
+ public:
+  void processPackets(MessageHandler& messages);
+  void initialize(uint32_t num_packets);
+  void setDoorbell(void* doorbell) { doorbell_ = doorbell; };
+  void setDevice(const amd::Device* dptr) { device_ = dptr; };
+
+ #if defined(__clang__)
+ #if __has_feature(address_sanitizer)
+ private:
+  device::UriLocator* uri_locator;
+ public:
+  void setUriLocator(device::UriLocator* uri_l) { uri_locator = uri_l; };
+ #endif
+ #endif
+};
+
+static_assert(std::is_standard_layout<HostcallBuffer>::value,
+              "the hostcall buffer must be useable from other languages");