mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-22 01:11:42 +00:00
Initial checkin of unified hierarchy of WPILib 2015
This commit is contained in:
Brad Miller
315
networktables/cpp/Win32/src/main/native/OSAL/Task.cpp
Normal file
315
networktables/cpp/Win32/src/main/native/OSAL/Task.cpp
Normal file
@@ -0,0 +1,315 @@
|
||||
#include "stdafx.h"
|
||||
#include "OSAL/Task.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <Windows.h>
|
||||
|
||||
|
||||
//const UINT32 NTTask::kDefaultPriority;
|
||||
//const INT32 NTTask::kInvalidTaskID;
|
||||
|
||||
/**
|
||||
* 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 priority for the task.
|
||||
* @param stackSize The size of the stack for the task
|
||||
*/
|
||||
NTTask::NTTask(const char* name, FUNCPTR function, INT32 priority, UINT32 stackSize)
|
||||
{
|
||||
//m_taskID = kInvalidTaskID;
|
||||
m_Handle=NULL;
|
||||
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);
|
||||
|
||||
//TODO see if we want to debug out this... it may be interesting info
|
||||
#if 0
|
||||
static INT32 instances = 0;
|
||||
instances++;
|
||||
#endif
|
||||
}
|
||||
|
||||
NTTask::~NTTask()
|
||||
{
|
||||
//if (m_taskID != kInvalidTaskID) Stop();
|
||||
if (m_Handle)
|
||||
Stop();
|
||||
delete [] m_taskName;
|
||||
m_taskName = NULL;
|
||||
}
|
||||
|
||||
// The thread callback
|
||||
DWORD thread_proc( void *p_ptr )
|
||||
{ // Get the pointer to myself
|
||||
NTTask *p_this = (NTTask*)p_ptr;
|
||||
assert( p_this );
|
||||
|
||||
(*p_this->m_function)( p_this->m_Arg );
|
||||
return 0;
|
||||
}
|
||||
|
||||
//This sets the name of the thread, which can help to identify threads in win32
|
||||
#define MS_VC_EXCEPTION 0x406D1388
|
||||
static void set_thread_name( const char *p_thread_name, DWORD ID )
|
||||
{
|
||||
#pragma pack(push,8)
|
||||
typedef struct tagTHREADNAME_INFO
|
||||
{ DWORD dwType; // Must be 0x1000.
|
||||
LPCSTR szName; // Pointer to name (in user addr space).
|
||||
DWORD dwThreadID; // Thread ID (-1=caller thread).
|
||||
DWORD dwFlags; // Reserved for future use, must be zero.
|
||||
|
||||
} THREADNAME_INFO;
|
||||
#pragma pack(pop)
|
||||
|
||||
// Set the information
|
||||
THREADNAME_INFO info = { 0x1000, p_thread_name, ID, 0 };
|
||||
|
||||
// Raise the exception
|
||||
__try { ::RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info ); }
|
||||
__except( EXCEPTION_EXECUTE_HANDLER ) {}
|
||||
}
|
||||
|
||||
bool NTTask::StartInternal()
|
||||
{
|
||||
if (m_Handle)
|
||||
{
|
||||
assert(false); // This may be lifted... just want to see if it happens
|
||||
Stop();
|
||||
}
|
||||
|
||||
m_Handle = ::CreateThread( NULL, m_stackSize, (LPTHREAD_START_ROUTINE)thread_proc, (void*)this, NULL, &m_ID );
|
||||
if (m_ID!=NULL)
|
||||
set_thread_name(m_taskName,m_ID);
|
||||
return m_Handle!=NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts this task.
|
||||
* If it is already running or unable to start, it fails and returns false.
|
||||
*/
|
||||
bool NTTask::Start(void *arg0)
|
||||
{
|
||||
m_Arg=arg0;
|
||||
return StartInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 NTTask::Restart()
|
||||
{
|
||||
//return HandleError(taskRestart(m_taskID));
|
||||
Stop();
|
||||
return StartInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Kills the running task.
|
||||
* @returns true on success false if the task doesn't exist or we are unable to kill it.
|
||||
*/
|
||||
bool NTTask::Stop()
|
||||
{
|
||||
if (!m_Handle) return false;
|
||||
bool ok = true;
|
||||
// Wait for the thread to finish
|
||||
#ifdef _DEBUG
|
||||
try_again:
|
||||
#endif _DEBUG
|
||||
|
||||
//const int TimeOut=2000;
|
||||
const int TimeOut=INFINITE;
|
||||
if ( ::WaitForSingleObject( m_Handle , TimeOut ) == WAIT_TIMEOUT )
|
||||
{ // Signal the thread as having been terminated
|
||||
//if ( m_p_error ) *m_p_error = true;
|
||||
|
||||
// If this gets triggered we have a bug in the code.
|
||||
#ifdef _DEBUG
|
||||
switch( ::MessageBoxW( NULL, L"A thread being used by the application\n"
|
||||
L"has taken to long to exit and so is about\n"
|
||||
L"to be terminated to avoid locking-up\n"
|
||||
L"the application.\n\n"
|
||||
L"Click ABORT to debug.\n"
|
||||
L"Click RETRY to wait for a bit longer.\n"
|
||||
L"Click IGNORE to terminate the thread.\n\n"
|
||||
L"This message is NOT displayed in release mode.",
|
||||
L"Thread exit has timed out.",
|
||||
MB_ABORTRETRYIGNORE ) )
|
||||
{ case IDRETRY: goto try_again;
|
||||
case IDABORT: ::DebugBreak(); break;
|
||||
case IDIGNORE: break;
|
||||
}
|
||||
#endif _DEBUG
|
||||
|
||||
// Free thread memory
|
||||
CONTEXT c_ = {0};
|
||||
c_.ContextFlags = CONTEXT_FULL;
|
||||
::GetThreadContext( m_Handle, &c_ );
|
||||
MEMORY_BASIC_INFORMATION Info_ = {0};
|
||||
|
||||
#ifdef _M_X64
|
||||
::VirtualQuery( (PVOID) c_.Rsp, &Info_, sizeof(Info_) );
|
||||
#else
|
||||
::VirtualQuery( (PVOID) c_.Esp, &Info_, sizeof(Info_) );
|
||||
#endif
|
||||
// Terminate the thread
|
||||
::TerminateThread( m_Handle, 0 );
|
||||
|
||||
// Free the memory
|
||||
::VirtualFree( Info_.AllocationBase, 0, MEM_RELEASE );
|
||||
}
|
||||
|
||||
//if (Verify())
|
||||
//{
|
||||
// ok = HandleError(taskDelete(m_taskID));
|
||||
//}
|
||||
//m_taskID = kInvalidTaskID;
|
||||
// The thread has finished
|
||||
|
||||
CloseHandle( m_Handle );
|
||||
m_Handle = NULL;
|
||||
return ok;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 NTTask::IsReady()
|
||||
{
|
||||
//return taskIsReady(m_taskID);
|
||||
return m_Handle!=NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the task was explicitly suspended by calling Suspend()
|
||||
* @return true if suspended, false if not suspended.
|
||||
*/
|
||||
bool NTTask::IsSuspended()
|
||||
{
|
||||
//return taskIsSuspended(m_taskID);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pauses a running task.
|
||||
* Returns true on success, false if unable to pause or the task isn't running.
|
||||
*/
|
||||
bool NTTask::Suspend()
|
||||
{
|
||||
//return HandleError(taskSuspend(m_taskID));
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resumes a paused task.
|
||||
* Returns true on success, false if unable to resume or if the task isn't running/paused.
|
||||
*/
|
||||
bool NTTask::Resume()
|
||||
{
|
||||
//return HandleError(taskResume(m_taskID));
|
||||
assert(false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies a task still exists.
|
||||
* @returns true on success.
|
||||
*/
|
||||
bool NTTask::Verify()
|
||||
{
|
||||
//return taskIdVerify(m_taskID) == OK;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the priority of a task.
|
||||
* @returns task priority or 0 if an error occured
|
||||
*/
|
||||
INT32 NTTask::GetPriority()
|
||||
{
|
||||
//if (HandleError(taskPriorityGet(m_taskID, &m_priority)))
|
||||
// return m_priority;
|
||||
//else
|
||||
// return 0;
|
||||
return m_priority;
|
||||
}
|
||||
|
||||
/**
|
||||
* This routine changes a task's priority to a specified priority.
|
||||
* Priorities range from 0, the highest priority, to 255, the lowest priority.
|
||||
* Default task priority is 100.
|
||||
* @param priority The priority the task should run at.
|
||||
* @returns true on success.
|
||||
*/
|
||||
bool NTTask::SetPriority(INT32 priority)
|
||||
{
|
||||
m_priority = priority;
|
||||
//return HandleError(taskPrioritySet(m_taskID, m_priority));
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the name of the task.
|
||||
* @returns Pointer to the name of the task or NULL if not allocated
|
||||
*/
|
||||
const char* NTTask::GetName()
|
||||
{
|
||||
return m_taskName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the ID of a task
|
||||
* @returns Task ID of this task. NTTask::kInvalidTaskID (-1) if the task has not been started or has already exited.
|
||||
*/
|
||||
INT32 NTTask::GetID()
|
||||
{
|
||||
//if (Verify())
|
||||
// return m_taskID;
|
||||
if (m_Handle)
|
||||
return m_ID;
|
||||
return kInvalidTaskID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles errors generated by task related code.
|
||||
*/
|
||||
bool NTTask::HandleError(STATUS results)
|
||||
{
|
||||
if (results != ERROR) return true;
|
||||
//switch(errnoGet())
|
||||
//{
|
||||
//case S_objLib_OBJ_ID_ERROR:
|
||||
// wpi_setWPIErrorWithContext(TaskIDError, m_taskName);
|
||||
// break;
|
||||
//
|
||||
//case S_objLib_OBJ_DELETED:
|
||||
// wpi_setWPIErrorWithContext(TaskDeletedError, m_taskName);
|
||||
// break;
|
||||
//
|
||||
//case S_taskLib_ILLEGAL_OPTIONS:
|
||||
// wpi_setWPIErrorWithContext(TaskOptionsError, m_taskName);
|
||||
// break;
|
||||
//
|
||||
//case S_memLib_NOT_ENOUGH_MEMORY:
|
||||
// wpi_setWPIErrorWithContext(TaskMemoryError, m_taskName);
|
||||
// break;
|
||||
//
|
||||
//case S_taskLib_ILLEGAL_PRIORITY:
|
||||
// wpi_setWPIErrorWithContext(TaskPriorityError, m_taskName);
|
||||
// break;
|
||||
|
||||
//default:
|
||||
// printErrno(errnoGet());
|
||||
// wpi_setWPIErrorWithContext(TaskError, m_taskName);
|
||||
//}
|
||||
return false;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user