mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-19 00:41:43 +00:00
c0ecde302f
If a lock is used with a mutex that doesn't need to be unlocked again before the lock is destroyed, std::lock_guard can be more efficient than std::unique_lock due to less overhead. This commit also removes a redundant set of curly braces in PIDController.cpp intended to constrain a lock's scope. Change-Id: Idd692ce439528ddb319a4c62c40c7351a664eb97
111 lines
3.3 KiB
C++
111 lines
3.3 KiB
C++
/*----------------------------------------------------------------------------*/
|
|
/* Copyright (c) FIRST 2008. All Rights Reserved. */
|
|
/* Open Source Software - may be modified and shared by FRC teams. The code */
|
|
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
#include "HAL/cpp/Resource.hpp"
|
|
#include "HAL/Errors.hpp"
|
|
#include <cstddef>
|
|
#include "HAL/cpp/priority_mutex.h"
|
|
|
|
namespace hal {
|
|
|
|
priority_recursive_mutex Resource::m_createLock;
|
|
|
|
/**
|
|
* Allocate storage for a new instance of Resource.
|
|
* Allocate a bool array of values that will get initialized to indicate that no resources
|
|
* have been allocated yet. The indicies of the resources are [0 .. elements - 1].
|
|
*/
|
|
Resource::Resource(uint32_t elements) {
|
|
std::lock_guard<priority_recursive_mutex> sync(m_createLock);
|
|
m_isAllocated = std::vector<bool>(elements, false);
|
|
}
|
|
|
|
/**
|
|
* Factory method to create a Resource allocation-tracker *if* needed.
|
|
*
|
|
* @param r -- address of the caller's Resource pointer. If *r == NULL, this
|
|
* will construct a Resource and make *r point to it. If *r != NULL, i.e.
|
|
* the caller already has a Resource instance, this won't do anything.
|
|
* @param elements -- the number of elements for this Resource allocator to
|
|
* track, that is, it will allocate resource numbers in the range
|
|
* [0 .. elements - 1].
|
|
*/
|
|
/*static*/ void Resource::CreateResourceObject(Resource **r, uint32_t elements)
|
|
{
|
|
std::lock_guard<priority_recursive_mutex> sync(m_createLock);
|
|
if (*r == NULL)
|
|
{
|
|
*r = new Resource(elements);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allocate a resource.
|
|
* When a resource is requested, mark it allocated. In this case, a free resource value
|
|
* within the range is located and returned after it is marked allocated.
|
|
*/
|
|
uint32_t Resource::Allocate(const char *resourceDesc)
|
|
{
|
|
std::lock_guard<priority_recursive_mutex> sync(m_allocateLock);
|
|
for (uint32_t i=0; i < m_isAllocated.size(); i++)
|
|
{
|
|
if (!m_isAllocated[i])
|
|
{
|
|
m_isAllocated[i] = true;
|
|
return i;
|
|
}
|
|
}
|
|
// TODO: wpi_setWPIErrorWithContext(NoAvailableResources, resourceDesc);
|
|
return ~0ul;
|
|
}
|
|
|
|
/**
|
|
* Allocate a specific resource value.
|
|
* The user requests a specific resource value, i.e. channel number and it is verified
|
|
* unallocated, then returned.
|
|
*/
|
|
uint32_t Resource::Allocate(uint32_t index, const char *resourceDesc)
|
|
{
|
|
std::lock_guard<priority_recursive_mutex> sync(m_allocateLock);
|
|
if (index >= m_isAllocated.size())
|
|
{
|
|
// TODO: wpi_setWPIErrorWithContext(ChannelIndexOutOfRange, resourceDesc);
|
|
return ~0ul;
|
|
}
|
|
if ( m_isAllocated[index] )
|
|
{
|
|
// TODO: wpi_setWPIErrorWithContext(ResourceAlreadyAllocated, resourceDesc);
|
|
return ~0ul;
|
|
}
|
|
m_isAllocated[index] = true;
|
|
return index;
|
|
}
|
|
|
|
|
|
/**
|
|
* Free an allocated resource.
|
|
* After a resource is no longer needed, for example a destructor is called for a channel assignment
|
|
* class, Free will release the resource value so it can be reused somewhere else in the program.
|
|
*/
|
|
void Resource::Free(uint32_t index)
|
|
{
|
|
std::lock_guard<priority_recursive_mutex> sync(m_allocateLock);
|
|
if (index == ~0ul) return;
|
|
if (index >= m_isAllocated.size())
|
|
{
|
|
// TODO: wpi_setWPIError(NotAllocated);
|
|
return;
|
|
}
|
|
if (!m_isAllocated[index])
|
|
{
|
|
// TODO: wpi_setWPIError(NotAllocated);
|
|
return;
|
|
}
|
|
m_isAllocated[index] = false;
|
|
}
|
|
|
|
} // namespace hal
|