Adds way to reset and version all HAL handles (#545)

Useful in the sim to force a full reset. On roboRIO, the information is
still created and added, but is not checked because of speed
considerations.

hal/include/HAL/handles/DigitalHandleResource.h

@@ -33,7 +33,7 @@ namespace hal {
  *
  */
 template <typename THandle, typename TStruct, int16_t size>
-class DigitalHandleResource {
+class DigitalHandleResource : public HandleBase {
   friend class DigitalHandleResourceTest;
 
  public:
@@ -44,6 +44,7 @@ class DigitalHandleResource {
   THandle Allocate(int16_t index, HAL_HandleEnum enumValue, int32_t* status);
   std::shared_ptr<TStruct> Get(THandle handle, HAL_HandleEnum enumValue);
   void Free(THandle handle, HAL_HandleEnum enumValue);
+  void ResetHandles() override;
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
@@ -65,14 +66,14 @@ THandle DigitalHandleResource<THandle, TStruct, size>::Allocate(
     return HAL_kInvalidHandle;
   }
   m_structures[index] = std::make_shared<TStruct>();
-  return static_cast<THandle>(hal::createHandle(index, enumValue));
+  return static_cast<THandle>(hal::createHandle(index, enumValue, m_version));
 }
 
 template <typename THandle, typename TStruct, int16_t size>
 std::shared_ptr<TStruct> DigitalHandleResource<THandle, TStruct, size>::Get(
     THandle handle, HAL_HandleEnum enumValue) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) {
     return nullptr;
   }
@@ -86,10 +87,19 @@ template <typename THandle, typename TStruct, int16_t size>
 void DigitalHandleResource<THandle, TStruct, size>::Free(
     THandle handle, HAL_HandleEnum enumValue) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
   std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, int16_t size>
+void DigitalHandleResource<THandle, TStruct, size>::ResetHandles() {
+  for (int i = 0; i < size; i++) {
+    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    m_structures[i].reset();
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal

hal/include/HAL/handles/HandlesInternal.h

@@ -13,7 +13,7 @@
 
 /* General Handle Data Layout
  * Bits 0-15:  Handle Index
- * Bits 16-23: Unused
+ * Bits 16-23: 8 bit rolling reset detection
  * Bits 24-30: Handle Type
  * Bit 31:     1 if handle error, 0 if no error
  *
@@ -23,6 +23,19 @@
 
 namespace hal {
 
+class HandleBase {
+ public:
+  HandleBase();
+  ~HandleBase();
+  HandleBase(const HandleBase&) = delete;
+  HandleBase& operator=(const HandleBase&) = delete;
+  virtual void ResetHandles();
+  static void ResetGlobalHandles();
+
+ protected:
+  int16_t m_version;
+};
+
 constexpr int16_t InvalidHandleIndex = -1;
 
 enum class HAL_HandleEnum {
@@ -57,9 +70,16 @@ static inline HAL_HandleEnum getHandleType(HAL_Handle handle) {
 static inline bool isHandleType(HAL_Handle handle, HAL_HandleEnum handleType) {
   return handleType == getHandleType(handle);
 }
+static inline bool isHandleCorrectVersion(HAL_Handle handle, int16_t version) {
+  return (((handle & 0xFF0000) >> 16) & version) == version;
+}
 static inline int16_t getHandleTypedIndex(HAL_Handle handle,
-                                          HAL_HandleEnum enumType) {
+                                          HAL_HandleEnum enumType,
+                                          int16_t version) {
   if (!isHandleType(handle, enumType)) return InvalidHandleIndex;
+#if !defined(CONFIG_ATHENA)
+  if (!isHandleCorrectVersion(handle, version)) return InvalidHandleIndex;
+#endif
   return getHandleIndex(handle);
 }
 
@@ -94,5 +114,6 @@ HAL_PortHandle createPortHandle(uint8_t channel, uint8_t module);
 
 HAL_PortHandle createPortHandleForSPI(uint8_t channel);
 
-HAL_Handle createHandle(int16_t index, HAL_HandleEnum handleType);
+HAL_Handle createHandle(int16_t index, HAL_HandleEnum handleType,
+                        int16_t version);
 }  // namespace hal

hal/include/HAL/handles/IndexedClassedHandleResource.h

@@ -35,7 +35,7 @@ namespace hal {
  */
 template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
-class IndexedClassedHandleResource {
+class IndexedClassedHandleResource : public HandleBase {
   friend class IndexedClassedHandleResourceTest;
 
  public:
@@ -50,9 +50,8 @@ class IndexedClassedHandleResource {
   void Free(THandle handle);
 
  private:
-  // Dynamic array to shrink HAL file size.
-  std::unique_ptr<std::shared_ptr<TStruct>[]> m_structures;
-  std::unique_ptr<hal::priority_mutex[]> m_handleMutexes;
+  std::array<std::shared_ptr<TStruct>[], size> m_structures;
+  std::array<hal::priority_mutex[], size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -80,7 +79,7 @@ IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     return HAL_kInvalidHandle;
   }
   m_structures[index] = toSet;
-  return static_cast<THandle>(hal::createHandle(index, enumValue));
+  return static_cast<THandle>(hal::createHandle(index, enumValue, m_version));
 }
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -88,7 +87,7 @@ template <typename THandle, typename TStruct, int16_t size,
 std::shared_ptr<TStruct> IndexedClassedHandleResource<
     THandle, TStruct, size, enumValue>::Get(THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) {
     return nullptr;
   }
@@ -103,10 +102,21 @@ template <typename THandle, typename TStruct, int16_t size,
 void IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Free(
     THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
   std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, int16_t size,
+          HAL_HandleEnum enumValue>
+void IndexedClassedHandleResource<THandle, TStruct, size,
+                                  enumValue>::ResetHandles() {
+  for (int i = 0; i < size; i++) {
+    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    m_structures[i].reset();
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal

hal/include/HAL/handles/IndexedHandleResource.h

@@ -34,7 +34,7 @@ namespace hal {
  */
 template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
-class IndexedHandleResource {
+class IndexedHandleResource : public HandleBase {
   friend class IndexedHandleResourceTest;
 
  public:
@@ -45,6 +45,7 @@ class IndexedHandleResource {
   THandle Allocate(int16_t index, int32_t* status);
   std::shared_ptr<TStruct> Get(THandle handle);
   void Free(THandle handle);
+  void ResetHandles() override;
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
@@ -67,7 +68,7 @@ THandle IndexedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     return HAL_kInvalidHandle;
   }
   m_structures[index] = std::make_shared<TStruct>();
-  return static_cast<THandle>(hal::createHandle(index, enumValue));
+  return static_cast<THandle>(hal::createHandle(index, enumValue, m_version));
 }
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -75,7 +76,7 @@ template <typename THandle, typename TStruct, int16_t size,
 std::shared_ptr<TStruct>
 IndexedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) {
     return nullptr;
   }
@@ -90,10 +91,20 @@ template <typename THandle, typename TStruct, int16_t size,
 void IndexedHandleResource<THandle, TStruct, size, enumValue>::Free(
     THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
   std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, int16_t size,
+          HAL_HandleEnum enumValue>
+void IndexedHandleResource<THandle, TStruct, size, enumValue>::ResetHandles() {
+  for (int i = 0; i < size; i++) {
+    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    m_structures[i].reset();
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal

hal/include/HAL/handles/LimitedClassedHandleResource.h

@@ -32,7 +32,7 @@ namespace hal {
  */
 template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
-class LimitedClassedHandleResource {
+class LimitedClassedHandleResource : public HandleBase {
   friend class LimitedClassedHandleResourceTest;
 
  public:
@@ -44,6 +44,7 @@ class LimitedClassedHandleResource {
   THandle Allocate(std::shared_ptr<TStruct> toSet);
   std::shared_ptr<TStruct> Get(THandle handle);
   void Free(THandle handle);
+  void ResetHandles() override;
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
@@ -64,7 +65,7 @@ LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
       // and allocate it.
       std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
       m_structures[i] = toSet;
-      return static_cast<THandle>(createHandle(i, enumValue));
+      return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
   }
   return HAL_kInvalidHandle;
@@ -75,7 +76,7 @@ template <typename THandle, typename TStruct, int16_t size,
 std::shared_ptr<TStruct> LimitedClassedHandleResource<
     THandle, TStruct, size, enumValue>::Get(THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) {
     return nullptr;
   }
@@ -90,11 +91,25 @@ template <typename THandle, typename TStruct, int16_t size,
 void LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Free(
     THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
   std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
   std::lock_guard<hal::priority_mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, int16_t size,
+          HAL_HandleEnum enumValue>
+void LimitedClassedHandleResource<THandle, TStruct, size,
+                                  enumValue>::ResetHandles() {
+  {
+    std::lock_guard<hal::priority_mutex> lock(m_allocateMutex);
+    for (int i = 0; i < size; i++) {
+      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      m_structures[i].reset();
+    }
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal

hal/include/HAL/handles/LimitedHandleResource.h

@@ -31,7 +31,7 @@ namespace hal {
  */
 template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
-class LimitedHandleResource {
+class LimitedHandleResource : public HandleBase {
   friend class LimitedHandleResourceTest;
 
  public:
@@ -42,6 +42,7 @@ class LimitedHandleResource {
   THandle Allocate();
   std::shared_ptr<TStruct> Get(THandle handle);
   void Free(THandle handle);
+  void ResetHandles() override;
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
@@ -60,7 +61,7 @@ THandle LimitedHandleResource<THandle, TStruct, size, enumValue>::Allocate() {
       // and allocate it.
       std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
       m_structures[i] = std::make_shared<TStruct>();
-      return static_cast<THandle>(createHandle(i, enumValue));
+      return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
   }
   return HAL_kInvalidHandle;
@@ -71,7 +72,7 @@ template <typename THandle, typename TStruct, int16_t size,
 std::shared_ptr<TStruct>
 LimitedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) {
     return nullptr;
   }
@@ -86,11 +87,24 @@ template <typename THandle, typename TStruct, int16_t size,
 void LimitedHandleResource<THandle, TStruct, size, enumValue>::Free(
     THandle handle) {
   // get handle index, and fail early if index out of range or wrong handle
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
   std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
   std::lock_guard<hal::priority_mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, int16_t size,
+          HAL_HandleEnum enumValue>
+void LimitedHandleResource<THandle, TStruct, size, enumValue>::ResetHandles() {
+  {
+    std::lock_guard<hal::priority_mutex> lock(m_allocateMutex);
+    for (int i = 0; i < size; i++) {
+      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      m_structures[i].reset();
+    }
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal

hal/include/HAL/handles/UnlimitedHandleResource.h

@@ -33,7 +33,7 @@ namespace hal {
  *
  */
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
-class UnlimitedHandleResource {
+class UnlimitedHandleResource : public HandleBase {
   friend class UnlimitedHandleResourceTest;
 
  public:
@@ -44,6 +44,7 @@ class UnlimitedHandleResource {
   THandle Allocate(std::shared_ptr<TStruct> structure);
   std::shared_ptr<TStruct> Get(THandle handle);
   void Free(THandle handle);
+  void ResetHandles() override;
 
  private:
   std::vector<std::shared_ptr<TStruct>> m_structures;
@@ -58,19 +59,20 @@ THandle UnlimitedHandleResource<THandle, TStruct, enumValue>::Allocate(
   for (i = 0; i < m_structures.size(); i++) {
     if (m_structures[i] == nullptr) {
       m_structures[i] = structure;
-      return static_cast<THandle>(createHandle(i, enumValue));
+      return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
   }
   if (i >= INT16_MAX) return HAL_kInvalidHandle;
 
   m_structures.push_back(structure);
-  return static_cast<THandle>(createHandle(static_cast<int16_t>(i), enumValue));
+  return static_cast<THandle>(
+      createHandle(static_cast<int16_t>(i), enumValue, m_version));
 }
 
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 std::shared_ptr<TStruct>
 UnlimitedHandleResource<THandle, TStruct, enumValue>::Get(THandle handle) {
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   std::lock_guard<hal::priority_mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size()))
     return nullptr;
@@ -80,9 +82,20 @@ UnlimitedHandleResource<THandle, TStruct, enumValue>::Get(THandle handle) {
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 void UnlimitedHandleResource<THandle, TStruct, enumValue>::Free(
     THandle handle) {
-  int16_t index = getHandleTypedIndex(handle, enumValue);
+  int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   std::lock_guard<hal::priority_mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size())) return;
   m_structures[index].reset();
 }
+
+template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
+void UnlimitedHandleResource<THandle, TStruct, enumValue>::ResetHandles() {
+  {
+    std::lock_guard<hal::priority_mutex> lock(m_handleMutex);
+    for (size_t i = 0; i < m_structures.size(); i++) {
+      m_structures[i].reset();
+    }
+  }
+  HandleBase::ResetHandles();
+}
 }  // namespace hal