Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change hal sim to use spinlocks (#1291)

Browse Source 
This makes callback registration completely thread safe.

This patch also uses templates and macros to dramatically reduce the amount of
manual boilerplate.
This commit is contained in:
Peter Johnson
2018-09-03 16:08:07 -07:00
committed by GitHub
parent 67b1c85315
commit c0ff6198b3
65 changed files with 1305 additions and 7639 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
hal/src/main/native/sim/mockdata/AnalogOutData.cpp
View File

@@ -7,7 +7,6 @@
#include "../PortsInternal.h"
#include "AnalogOutDataInternal.h"
#include "mockdata/NotifyCallbackHelpers.h"
using namespace hal;
@@ -22,82 +21,8 @@ void InitializeAnalogOutData() {
AnalogOutData* hal::SimAnalogOutData;
void AnalogOutData::ResetData() {
m_voltage = 0.0;
m_voltageCallbacks = nullptr;
m_initialized = 0;
m_initializedCallbacks = nullptr;
}
int32_t AnalogOutData::RegisterVoltageCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<wpi::mutex> lock(m_registerMutex);
m_voltageCallbacks = RegisterCallback(m_voltageCallbacks, "Voltage",
callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeDouble(GetVoltage());
callback("Voltage", param, &value);
}
return newUid;
}
void AnalogOutData::CancelVoltageCallback(int32_t uid) {
m_voltageCallbacks = CancelCallback(m_voltageCallbacks, uid);
}
void AnalogOutData::InvokeVoltageCallback(HAL_Value value) {
InvokeCallback(m_voltageCallbacks, "Voltage", &value);
}
double AnalogOutData::GetVoltage() { return m_voltage; }
void AnalogOutData::SetVoltage(double voltage) {
double oldValue = m_voltage.exchange(voltage);
if (oldValue != voltage) {
InvokeVoltageCallback(MakeDouble(voltage));
}
}
int32_t AnalogOutData::RegisterInitializedCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<wpi::mutex> lock(m_registerMutex);
m_initializedCallbacks = RegisterCallback(
m_initializedCallbacks, "Initialized", callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeBoolean(GetInitialized());
callback("Initialized", param, &value);
}
return newUid;
}
void AnalogOutData::CancelInitializedCallback(int32_t uid) {
m_initializedCallbacks = CancelCallback(m_initializedCallbacks, uid);
}
void AnalogOutData::InvokeInitializedCallback(HAL_Value value) {
InvokeCallback(m_initializedCallbacks, "Initialized", &value);
}
HAL_Bool AnalogOutData::GetInitialized() { return m_initialized; }
void AnalogOutData::SetInitialized(HAL_Bool initialized) {
HAL_Bool oldValue = m_initialized.exchange(initialized);
if (oldValue != initialized) {
InvokeInitializedCallback(MakeBoolean(initialized));
}
voltage.Reset(0.0);
initialized.Reset(0);
}
extern "C" {
@@ -105,52 +30,20 @@ void HALSIM_ResetAnalogOutData(int32_t index) {
SimAnalogOutData[index].ResetData();
}
int32_t HALSIM_RegisterAnalogOutVoltageCallback(int32_t index,
HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
return SimAnalogOutData[index].RegisterVoltageCallback(callback, param,
initialNotify);
}
#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \
HAL_SIMDATAVALUE_DEFINE_CAPI(TYPE, HALSIM, AnalogOut##CAPINAME, \
SimAnalogOutData, LOWERNAME)
void HALSIM_CancelAnalogOutVoltageCallback(int32_t index, int32_t uid) {
SimAnalogOutData[index].CancelVoltageCallback(uid);
}
DEFINE_CAPI(double, Voltage, voltage)
DEFINE_CAPI(HAL_Bool, Initialized, initialized)
double HALSIM_GetAnalogOutVoltage(int32_t index) {
return SimAnalogOutData[index].GetVoltage();
}
void HALSIM_SetAnalogOutVoltage(int32_t index, double voltage) {
SimAnalogOutData[index].SetVoltage(voltage);
}
int32_t HALSIM_RegisterAnalogOutInitializedCallback(int32_t index,
HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
return SimAnalogOutData[index].RegisterInitializedCallback(callback, param,
initialNotify);
}
void HALSIM_CancelAnalogOutInitializedCallback(int32_t index, int32_t uid) {
SimAnalogOutData[index].CancelInitializedCallback(uid);
}
HAL_Bool HALSIM_GetAnalogOutInitialized(int32_t index) {
return SimAnalogOutData[index].GetInitialized();
}
void HALSIM_SetAnalogOutInitialized(int32_t index, HAL_Bool initialized) {
SimAnalogOutData[index].SetInitialized(initialized);
}
#define REGISTER(NAME) \
SimAnalogOutData[index].NAME.RegisterCallback(callback, param, initialNotify)
void HALSIM_RegisterAnalogOutAllCallbacks(int32_t index,
HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify) {
SimAnalogOutData[index].RegisterVoltageCallback(callback, param,
initialNotify);
SimAnalogOutData[index].RegisterInitializedCallback(callback, param,
initialNotify);
REGISTER(voltage);
REGISTER(initialized);
}
} // extern "C"