Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-03 03:01:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

artf4149: Removed references to VxWorks

Browse Source 
Implemented setTaskPriority() and getTaskPriority() in Task HAL API

Removed all other unimplemented functions in HAL and removed spawnTask()

Replaced instances of pthread_t* with TASK typedef

Removed unused HAL error constants and removed commented-out classes and functions in wpilibj's HALLibrary

Changed Task class API to match the construction semantics of a std::thread

Change-Id: I3bc951a3da90d24c5589fae4d1ca2bb60225c873
This commit is contained in:
Tyler Veness
2014-08-14 00:07:02 -07:00
committed by James Kuszmaul
parent 5712565068
commit fd4c169658
41 changed files with 214 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
wpilibc/wpilibC++Devices/src/Task.cpp
View File

@@ -12,7 +12,6 @@
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include "HAL/HAL.hpp"
#ifndef OK
#define OK 0
@@ -23,115 +22,57 @@
const uint32_t Task::kDefaultPriority;
/**
* Create but don't launch a task.
* @param name The name of the task. "FRC_" will be prepended to the task name.
* @param function The address of the function to run as the new task.
* @param priority The VxWorks priority for the task.
* @param stackSize The size of the stack for the task
*/
Task::Task(const char* name, FUNCPTR function, int32_t priority,
uint32_t stackSize) {
m_function = function;
m_priority = priority;
m_stackSize = stackSize;
m_taskName = new char[strlen(name) + 5];
strcpy(m_taskName, "FRC_");
strcpy(m_taskName + 4, name);
Task& Task::operator=(Task&& task) {
m_thread.swap(task.m_thread);
m_taskName = std::move(task.m_taskName);
static int32_t instances = 0;
instances++;
HALReport(HALUsageReporting::kResourceType_Task, instances, 0, m_taskName);
return *this;
}
Task::~Task() {
if (m_taskID != NULL_TASK) Stop();
delete[] m_taskName;
m_taskName = nullptr;
}
/**
* Starts this task.
* If it is already running or unable to start, it fails and returns false.
*/
bool Task::Start(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3,
uint32_t arg4, uint32_t arg5, uint32_t arg6, uint32_t arg7,
uint32_t arg8, uint32_t arg9) {
m_taskID = spawnTask(
m_taskName, m_priority,
VXWORKS_FP_TASK, // options
m_stackSize, // stack size
m_function, // function to start
arg0, arg1, arg2, arg3, arg4, // parameter 1 - pointer to this class
arg5, arg6, arg7, arg8, arg9); // additional unused parameters
if (m_taskID == NULL_TASK) {
HandleError(ERROR);
return false;
if (m_thread.joinable()) {
std::cout << "[HAL] Exited task " << m_taskName << std::endl;
}
return true;
}
/**
* Restarts a running task.
* If the task isn't started, it starts it.
* @return false if the task is running and we are unable to kill the previous
* instance
*/
bool Task::Restart() { return HandleError(restartTask(m_taskID)); }
/**
* Kills the running task.
* @returns true on success false if the task doesn't exist or we are unable to
* kill it.
*/
bool Task::Stop() {
bool ok = true;
if (Verify()) {
ok = HandleError(deleteTask(m_taskID));
}
m_taskID = NULL_TASK;
return ok;
bool Task::joinable() const noexcept {
return m_thread.joinable();
}
/**
* Returns true if the task is ready to execute (i.e. not suspended, delayed, or
* blocked).
* @return true if ready, false if not ready.
*/
bool Task::IsReady() const { return isTaskReady(m_taskID); }
void Task::join() {
m_thread.join();
}
/**
* Returns true if the task was explicitly suspended by calling Suspend()
* @return true if suspended, false if not suspended.
*/
bool Task::IsSuspended() const { return isTaskSuspended(m_taskID); }
void Task::detach() {
m_thread.detach();
}
/**
* Pauses a running task.
* Returns true on success, false if unable to pause or the task isn't running.
*/
bool Task::Suspend() { return HandleError(suspendTask(m_taskID)); }
std::thread::id Task::get_id() const noexcept {
return m_thread.get_id();
}
/**
* Resumes a paused task.
* Returns true on success, false if unable to resume or if the task isn't
* running/paused.
*/
bool Task::Resume() { return HandleError(resumeTask(m_taskID)); }
std::thread::native_handle_type Task::native_handle() {
return m_thread.native_handle();
}
/**
* Verifies a task still exists.
* @returns true on success.
*/
bool Task::Verify() const { return verifyTaskID(m_taskID) == OK; }
bool Task::Verify() {
TASK id = (TASK)m_thread.native_handle();
return verifyTaskID(id) == OK;
}
/**
* Gets the priority of a task.
* @returns task priority or 0 if an error occured
*/
int32_t Task::GetPriority() {
if (HandleError(getTaskPriority(m_taskID, &m_priority)))
return m_priority;
int priority;
auto id = m_thread.native_handle();
if (HandleError(getTaskPriority(&id, &priority)))
return priority;
else
return 0;
}
@@ -144,25 +85,15 @@ int32_t Task::GetPriority() {
* @returns true on success.
*/
bool Task::SetPriority(int32_t priority) {
m_priority = priority;
return HandleError(setTaskPriority(m_taskID, m_priority));
auto id = m_thread.native_handle();
return HandleError(setTaskPriority(&id, priority));
}
/**
* Returns the name of the task.
* @returns Pointer to the name of the task or nullptr if not allocated
*/
const char* Task::GetName() const { return m_taskName; }
/**
* Get the ID of a task
* @returns Task ID of this task. Task::kInvalidTaskID (-1) if the task has not
* been started or has already exited.
*/
TASK Task::GetID() const {
if (Verify()) return m_taskID;
return NULL_TASK;
}
std::string Task::GetName() const { return m_taskName; }
/**
* Handles errors generated by task related code.
@@ -170,19 +101,11 @@ TASK Task::GetID() const {
bool Task::HandleError(STATUS results) {
if (results != ERROR) return true;
int errsv = errno;
if (errsv == HAL_objLib_OBJ_ID_ERROR) {
wpi_setWPIErrorWithContext(TaskIDError, m_taskName);
} else if (errsv == HAL_objLib_OBJ_DELETED) {
wpi_setWPIErrorWithContext(TaskDeletedError, m_taskName);
} else if (errsv == HAL_taskLib_ILLEGAL_OPTIONS) {
wpi_setWPIErrorWithContext(TaskOptionsError, m_taskName);
} else if (errsv == HAL_memLib_NOT_ENOUGH_MEMORY) {
wpi_setWPIErrorWithContext(TaskMemoryError, m_taskName);
} else if (errsv == HAL_taskLib_ILLEGAL_PRIORITY) {
wpi_setWPIErrorWithContext(TaskPriorityError, m_taskName);
if (errsv == HAL_taskLib_ILLEGAL_PRIORITY) {
wpi_setWPIErrorWithContext(TaskPriorityError, m_taskName.c_str());
} else {
printf("ERROR: errno=%i", errsv);
wpi_setWPIErrorWithContext(TaskError, m_taskName);
wpi_setWPIErrorWithContext(TaskError, m_taskName.c_str());
}
return false;
}