mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-14 05:26:32 +02:00
switch from pthread mutex to QMutex
This commit is contained in:
Brad Hefta-Gaub
parent
2c30b8b5b4
commit
9bc4a3df41
12 changed files with 111 additions and 131 deletions
|
|
@ -74,9 +74,6 @@ VoxelSystem::VoxelSystem(float treeScale, int maxVoxels)
|
|||
_tree = new VoxelTree();
|
||||
|
||||
_tree->getRoot()->setVoxelSystem(this);
|
||||
pthread_mutex_init(&_bufferWriteLock, NULL);
|
||||
pthread_mutex_init(&_treeLock, NULL);
|
||||
pthread_mutex_init(&_freeIndexLock, NULL);
|
||||
|
||||
VoxelTreeElement::addDeleteHook(this);
|
||||
VoxelTreeElement::addUpdateHook(this);
|
||||
|
|
@ -188,10 +185,10 @@ glBufferIndex VoxelSystem::getNextBufferIndex() {
|
|||
glBufferIndex output = GLBUFFER_INDEX_UNKNOWN;
|
||||
// if there's a free index, use it...
|
||||
if (_freeIndexes.size() > 0) {
|
||||
pthread_mutex_lock(&_freeIndexLock);
|
||||
_freeIndexLock.lock();
|
||||
output = _freeIndexes.back();
|
||||
_freeIndexes.pop_back();
|
||||
pthread_mutex_unlock(&_freeIndexLock);
|
||||
_freeIndexLock.unlock();
|
||||
} else {
|
||||
output = _voxelsInWriteArrays;
|
||||
_voxelsInWriteArrays++;
|
||||
|
|
@ -222,9 +219,9 @@ void VoxelSystem::freeBufferIndex(glBufferIndex index) {
|
|||
}
|
||||
if (!inList) {
|
||||
// make the index available for next node that needs to be drawn
|
||||
pthread_mutex_lock(&_freeIndexLock);
|
||||
_freeIndexLock.lock();
|
||||
_freeIndexes.push_back(index);
|
||||
pthread_mutex_unlock(&_freeIndexLock);
|
||||
_freeIndexLock.unlock();
|
||||
|
||||
// make the VBO slot "invisible" in case this slot is not used
|
||||
const glm::vec3 startVertex(FLT_MAX, FLT_MAX, FLT_MAX);
|
||||
|
|
@ -243,14 +240,14 @@ void VoxelSystem::clearFreeBufferIndexes() {
|
|||
|
||||
// clear out freeIndexes
|
||||
{
|
||||
PerformanceWarning warn(showWarnings,"clearFreeBufferIndexes() : pthread_mutex_lock(&_freeIndexLock)");
|
||||
pthread_mutex_lock(&_freeIndexLock);
|
||||
PerformanceWarning warn(showWarnings,"clearFreeBufferIndexes() : _freeIndexLock.lock()");
|
||||
_freeIndexLock.lock();
|
||||
}
|
||||
{
|
||||
PerformanceWarning warn(showWarnings,"clearFreeBufferIndexes() : _freeIndexes.clear()");
|
||||
_freeIndexes.clear();
|
||||
}
|
||||
pthread_mutex_unlock(&_freeIndexLock);
|
||||
_freeIndexLock.unlock();
|
||||
}
|
||||
|
||||
VoxelSystem::~VoxelSystem() {
|
||||
|
|
@ -259,9 +256,6 @@ VoxelSystem::~VoxelSystem() {
|
|||
|
||||
cleanupVoxelMemory();
|
||||
delete _tree;
|
||||
pthread_mutex_destroy(&_bufferWriteLock);
|
||||
pthread_mutex_destroy(&_treeLock);
|
||||
pthread_mutex_destroy(&_freeIndexLock);
|
||||
}
|
||||
|
||||
void VoxelSystem::setMaxVoxels(int maxVoxels) {
|
||||
|
|
@ -345,7 +339,7 @@ void VoxelSystem::setVoxelsAsPoints(bool voxelsAsPoints) {
|
|||
|
||||
void VoxelSystem::cleanupVoxelMemory() {
|
||||
if (_initialized) {
|
||||
pthread_mutex_lock(&_bufferWriteLock);
|
||||
_bufferWriteLock.lock();
|
||||
_initialized = false; // no longer initialized
|
||||
if (_useVoxelShader) {
|
||||
// these are used when in VoxelShader mode.
|
||||
|
|
@ -383,7 +377,7 @@ void VoxelSystem::cleanupVoxelMemory() {
|
|||
delete[] _writeVoxelDirtyArray;
|
||||
delete[] _readVoxelDirtyArray;
|
||||
_writeVoxelDirtyArray = _readVoxelDirtyArray = NULL;
|
||||
pthread_mutex_unlock(&_bufferWriteLock);
|
||||
_bufferWriteLock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -416,7 +410,7 @@ void VoxelSystem::setupFaceIndices(GLuint& faceVBOID, GLubyte faceIdentityIndice
|
|||
}
|
||||
|
||||
void VoxelSystem::initVoxelMemory() {
|
||||
pthread_mutex_lock(&_bufferWriteLock);
|
||||
_bufferWriteLock.lock();
|
||||
|
||||
_memoryUsageRAM = 0;
|
||||
_memoryUsageVBO = 0; // our VBO allocations as we know them
|
||||
|
|
@ -531,7 +525,7 @@ void VoxelSystem::initVoxelMemory() {
|
|||
|
||||
_initialized = true;
|
||||
|
||||
pthread_mutex_unlock(&_bufferWriteLock);
|
||||
_bufferWriteLock.unlock();
|
||||
}
|
||||
|
||||
void VoxelSystem::writeToSVOFile(const char* filename, VoxelTreeElement* element) const {
|
||||
|
|
@ -685,7 +679,7 @@ void VoxelSystem::setupNewVoxelsForDrawing() {
|
|||
}
|
||||
|
||||
// lock on the buffer write lock so we can't modify the data when the GPU is reading it
|
||||
pthread_mutex_lock(&_bufferWriteLock);
|
||||
_bufferWriteLock.lock();
|
||||
|
||||
if (_voxelsUpdated) {
|
||||
_voxelsDirty=true;
|
||||
|
|
@ -694,7 +688,7 @@ void VoxelSystem::setupNewVoxelsForDrawing() {
|
|||
// copy the newly written data to the arrays designated for reading, only does something if _voxelsDirty && _voxelsUpdated
|
||||
copyWrittenDataToReadArrays(didWriteFullVBO);
|
||||
|
||||
pthread_mutex_unlock(&_bufferWriteLock);
|
||||
_bufferWriteLock.unlock();
|
||||
|
||||
uint64_t end = usecTimestampNow();
|
||||
int elapsedmsec = (end - start) / 1000;
|
||||
|
|
@ -725,8 +719,8 @@ void VoxelSystem::setupNewVoxelsForDrawingSingleNode(bool allowBailEarly) {
|
|||
// lock on the buffer write lock so we can't modify the data when the GPU is reading it
|
||||
{
|
||||
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
|
||||
"setupNewVoxelsForDrawingSingleNode()... pthread_mutex_lock(&_bufferWriteLock);");
|
||||
pthread_mutex_lock(&_bufferWriteLock);
|
||||
"setupNewVoxelsForDrawingSingleNode()... _bufferWriteLock.lock();" );
|
||||
_bufferWriteLock.lock();
|
||||
}
|
||||
|
||||
_voxelsDirty = true; // if we got this far, then we can assume some voxels are dirty
|
||||
|
|
@ -737,7 +731,7 @@ void VoxelSystem::setupNewVoxelsForDrawingSingleNode(bool allowBailEarly) {
|
|||
// after...
|
||||
_voxelsUpdated = 0;
|
||||
|
||||
pthread_mutex_unlock(&_bufferWriteLock);
|
||||
_bufferWriteLock.unlock();
|
||||
|
||||
uint64_t end = usecTimestampNow();
|
||||
int elapsedmsec = (end - start) / 1000;
|
||||
|
|
@ -2766,13 +2760,13 @@ unsigned long VoxelSystem::getVoxelMemoryUsageGPU() {
|
|||
}
|
||||
|
||||
void VoxelSystem::lockTree() {
|
||||
pthread_mutex_lock(&_treeLock);
|
||||
_treeLock.lock();
|
||||
_treeIsBusy = true;
|
||||
}
|
||||
|
||||
void VoxelSystem::unlockTree() {
|
||||
_treeIsBusy = false;
|
||||
pthread_mutex_unlock(&_treeLock);
|
||||
_treeLock.unlock();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -260,8 +260,8 @@ private:
|
|||
GLuint _vboIndicesFront;
|
||||
GLuint _vboIndicesBack;
|
||||
|
||||
pthread_mutex_t _bufferWriteLock;
|
||||
pthread_mutex_t _treeLock;
|
||||
QMutex _bufferWriteLock;
|
||||
QMutex _treeLock;
|
||||
|
||||
ViewFrustum _lastKnownViewFrustum;
|
||||
ViewFrustum _lastStableViewFrustum;
|
||||
|
|
@ -287,7 +287,7 @@ private:
|
|||
|
||||
int _hookID;
|
||||
std::vector<glBufferIndex> _freeIndexes;
|
||||
pthread_mutex_t _freeIndexLock;
|
||||
QMutex _freeIndexLock;
|
||||
|
||||
void freeBufferIndex(glBufferIndex index);
|
||||
void clearFreeBufferIndexes();
|
||||
|
|
|
|||
|
|
@ -111,11 +111,11 @@ void LogDialog::resizeEvent(QResizeEvent*) {
|
|||
|
||||
void LogDialog::appendLogLine(QString logLine) {
|
||||
if (isVisible()) {
|
||||
pthread_mutex_lock(& _mutex);
|
||||
_mutex.lock();
|
||||
if (logLine.contains(_searchTerm, Qt::CaseInsensitive)) {
|
||||
_logTextBox->appendPlainText(logLine.simplified());
|
||||
}
|
||||
pthread_mutex_unlock(& _mutex);
|
||||
_mutex.unlock();
|
||||
_logTextBox->ensureCursorVisible();
|
||||
}
|
||||
}
|
||||
|
|
@ -140,13 +140,12 @@ void LogDialog::handleSearchTextChanged(const QString searchText) {
|
|||
|
||||
void LogDialog::showLogData() {
|
||||
_logTextBox->clear();
|
||||
pthread_mutex_lock(& _mutex);
|
||||
_mutex.lock();
|
||||
QStringList _logData = _logger->getLogData();
|
||||
for (int i = 0; i < _logData.size(); ++i) {
|
||||
appendLogLine(_logData[i]);
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(& _mutex);
|
||||
_mutex.unlock();
|
||||
}
|
||||
|
||||
KeywordHighlighter::KeywordHighlighter(QTextDocument *parent) : QSyntaxHighlighter(parent), keywordFormat() {
|
||||
|
|
|
|||
|
|
@ -10,12 +10,12 @@
|
|||
#define __interface__LogDialog__
|
||||
|
||||
#include <QDialog>
|
||||
#include <QMutex>
|
||||
#include <QPlainTextEdit>
|
||||
#include <QLineEdit>
|
||||
#include <QPushButton>
|
||||
#include <QCheckBox>
|
||||
#include <QSyntaxHighlighter>
|
||||
#include <pthread.h>
|
||||
|
||||
#include "AbstractLoggerInterface.h"
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ protected:
|
|||
|
||||
private:
|
||||
QTextCharFormat keywordFormat;
|
||||
|
||||
|
||||
};
|
||||
|
||||
class LogDialog : public QDialog {
|
||||
|
|
@ -60,7 +60,7 @@ private:
|
|||
QCheckBox* _extraDebuggingBox;
|
||||
QPushButton* _revealLogButton;
|
||||
QPlainTextEdit* _logTextBox;
|
||||
pthread_mutex_t _mutex;
|
||||
QMutex _mutex;
|
||||
QString _searchTerm;
|
||||
KeywordHighlighter* _highlighter;
|
||||
|
||||
|
|
|
|||
|
|
@ -22,11 +22,9 @@ JurisdictionSender::JurisdictionSender(JurisdictionMap* map, NODE_TYPE type, Pac
|
|||
_jurisdictionMap(map)
|
||||
{
|
||||
_nodeType = type;
|
||||
pthread_mutex_init(&_requestingNodeMutex, 0);
|
||||
}
|
||||
|
||||
JurisdictionSender::~JurisdictionSender() {
|
||||
pthread_mutex_destroy(&_requestingNodeMutex);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
#define __shared__JurisdictionSender__
|
||||
|
||||
#include <queue>
|
||||
#include <QMutex>
|
||||
|
||||
#include <PacketSender.h>
|
||||
#include <ReceivedPacketProcessor.h>
|
||||
|
|
@ -38,14 +39,14 @@ protected:
|
|||
virtual void processPacket(const HifiSockAddr& senderAddress, unsigned char* packetData, ssize_t packetLength);
|
||||
|
||||
/// Locks all the resources of the thread.
|
||||
void lockRequestingNodes() { pthread_mutex_lock(&_requestingNodeMutex); }
|
||||
void lockRequestingNodes() { _requestingNodeMutex.lock(); }
|
||||
|
||||
/// Unlocks all the resources of the thread.
|
||||
void unlockRequestingNodes() { pthread_mutex_unlock(&_requestingNodeMutex); }
|
||||
|
||||
void unlockRequestingNodes() { _requestingNodeMutex.unlock(); }
|
||||
|
||||
|
||||
private:
|
||||
pthread_mutex_t _requestingNodeMutex;
|
||||
QMutex _requestingNodeMutex;
|
||||
JurisdictionMap* _jurisdictionMap;
|
||||
std::queue<QUuid> _nodesRequestingJurisdictions;
|
||||
NODE_TYPE _nodeType;
|
||||
|
|
|
|||
|
|
@ -43,20 +43,12 @@ Octree::Octree(bool shouldReaverage) :
|
|||
_shouldReaverage(shouldReaverage),
|
||||
_stopImport(false) {
|
||||
_rootNode = NULL;
|
||||
|
||||
pthread_mutex_init(&_encodeSetLock, NULL);
|
||||
pthread_mutex_init(&_deleteSetLock, NULL);
|
||||
pthread_mutex_init(&_deletePendingSetLock, NULL);
|
||||
}
|
||||
|
||||
Octree::~Octree() {
|
||||
// delete the children of the root node
|
||||
// this recursively deletes the tree
|
||||
delete _rootNode;
|
||||
|
||||
pthread_mutex_destroy(&_encodeSetLock);
|
||||
pthread_mutex_destroy(&_deleteSetLock);
|
||||
pthread_mutex_destroy(&_deletePendingSetLock);
|
||||
}
|
||||
|
||||
// Recurses voxel tree calling the RecurseOctreeOperation function for each node.
|
||||
|
|
@ -1504,53 +1496,53 @@ void dumpSetContents(const char* name, std::set<unsigned char*> set) {
|
|||
}
|
||||
|
||||
void Octree::startEncoding(OctreeElement* node) {
|
||||
pthread_mutex_lock(&_encodeSetLock);
|
||||
_encodeSetLock.lock();
|
||||
_codesBeingEncoded.insert(node->getOctalCode());
|
||||
pthread_mutex_unlock(&_encodeSetLock);
|
||||
_encodeSetLock.unlock();
|
||||
}
|
||||
|
||||
void Octree::doneEncoding(OctreeElement* node) {
|
||||
pthread_mutex_lock(&_encodeSetLock);
|
||||
_encodeSetLock.lock();
|
||||
_codesBeingEncoded.erase(node->getOctalCode());
|
||||
pthread_mutex_unlock(&_encodeSetLock);
|
||||
_encodeSetLock.unlock();
|
||||
|
||||
// if we have any pending delete codes, then delete them now.
|
||||
emptyDeleteQueue();
|
||||
}
|
||||
|
||||
void Octree::startDeleting(const unsigned char* code) {
|
||||
pthread_mutex_lock(&_deleteSetLock);
|
||||
_deleteSetLock.lock();
|
||||
_codesBeingDeleted.insert(code);
|
||||
pthread_mutex_unlock(&_deleteSetLock);
|
||||
_deleteSetLock.unlock();
|
||||
}
|
||||
|
||||
void Octree::doneDeleting(const unsigned char* code) {
|
||||
pthread_mutex_lock(&_deleteSetLock);
|
||||
_deleteSetLock.lock();
|
||||
_codesBeingDeleted.erase(code);
|
||||
pthread_mutex_unlock(&_deleteSetLock);
|
||||
_deleteSetLock.unlock();
|
||||
}
|
||||
|
||||
bool Octree::isEncoding(const unsigned char* codeBuffer) {
|
||||
pthread_mutex_lock(&_encodeSetLock);
|
||||
_encodeSetLock.lock();
|
||||
bool isEncoding = (_codesBeingEncoded.find(codeBuffer) != _codesBeingEncoded.end());
|
||||
pthread_mutex_unlock(&_encodeSetLock);
|
||||
_encodeSetLock.unlock();
|
||||
return isEncoding;
|
||||
}
|
||||
|
||||
void Octree::queueForLaterDelete(const unsigned char* codeBuffer) {
|
||||
pthread_mutex_lock(&_deletePendingSetLock);
|
||||
_deletePendingSetLock.lock();
|
||||
_codesPendingDelete.insert(codeBuffer);
|
||||
pthread_mutex_unlock(&_deletePendingSetLock);
|
||||
_deletePendingSetLock.unlock();
|
||||
}
|
||||
|
||||
void Octree::emptyDeleteQueue() {
|
||||
pthread_mutex_lock(&_deletePendingSetLock);
|
||||
_deletePendingSetLock.lock();
|
||||
for (std::set<const unsigned char*>::iterator i = _codesPendingDelete.begin(); i != _codesPendingDelete.end(); ++i) {
|
||||
const unsigned char* codeToDelete = *i;
|
||||
_codesBeingDeleted.erase(codeToDelete);
|
||||
deleteOctalCodeFromTree(codeToDelete, COLLAPSE_EMPTY_TREE);
|
||||
}
|
||||
pthread_mutex_unlock(&_deletePendingSetLock);
|
||||
_deletePendingSetLock.unlock();
|
||||
}
|
||||
|
||||
void Octree::cancelImport() {
|
||||
|
|
|
|||
|
|
@ -72,12 +72,12 @@ public:
|
|||
OctreeSceneStats* stats;
|
||||
CoverageMap* map;
|
||||
JurisdictionMap* jurisdictionMap;
|
||||
|
||||
|
||||
// output hints from the encode process
|
||||
typedef enum {
|
||||
UNKNOWN,
|
||||
DIDNT_FIT,
|
||||
NULL_NODE,
|
||||
UNKNOWN,
|
||||
DIDNT_FIT,
|
||||
NULL_NODE,
|
||||
TOO_DEEP,
|
||||
OUT_OF_JURISDICTION,
|
||||
LOD_SKIP,
|
||||
|
|
@ -87,14 +87,14 @@ public:
|
|||
OCCLUDED
|
||||
} reason;
|
||||
reason stopReason;
|
||||
|
||||
|
||||
EncodeBitstreamParams(
|
||||
int maxEncodeLevel = INT_MAX,
|
||||
int maxEncodeLevel = INT_MAX,
|
||||
const ViewFrustum* viewFrustum = IGNORE_VIEW_FRUSTUM,
|
||||
bool includeColor = WANT_COLOR,
|
||||
bool includeColor = WANT_COLOR,
|
||||
bool includeExistsBits = WANT_EXISTS_BITS,
|
||||
int chopLevels = 0,
|
||||
bool deltaViewFrustum = false,
|
||||
int chopLevels = 0,
|
||||
bool deltaViewFrustum = false,
|
||||
const ViewFrustum* lastViewFrustum = IGNORE_VIEW_FRUSTUM,
|
||||
bool wantOcclusionCulling = NO_OCCLUSION_CULLING,
|
||||
CoverageMap* map = IGNORE_COVERAGE_MAP,
|
||||
|
|
@ -122,13 +122,13 @@ public:
|
|||
jurisdictionMap(jurisdictionMap),
|
||||
stopReason(UNKNOWN)
|
||||
{}
|
||||
|
||||
|
||||
void displayStopReason() {
|
||||
printf("StopReason: ");
|
||||
switch (stopReason) {
|
||||
default:
|
||||
case UNKNOWN: printf("UNKNOWN\n"); break;
|
||||
|
||||
|
||||
case DIDNT_FIT: printf("DIDNT_FIT\n"); break;
|
||||
case NULL_NODE: printf("NULL_NODE\n"); break;
|
||||
case TOO_DEEP: printf("TOO_DEEP\n"); break;
|
||||
|
|
@ -158,9 +158,9 @@ public:
|
|||
QUuid sourceUUID;
|
||||
Node* sourceNode;
|
||||
bool wantImportProgress;
|
||||
|
||||
|
||||
ReadBitstreamToTreeParams(
|
||||
bool includeColor = WANT_COLOR,
|
||||
bool includeColor = WANT_COLOR,
|
||||
bool includeExistsBits = WANT_EXISTS_BITS,
|
||||
OctreeElement* destinationNode = NULL,
|
||||
QUuid sourceUUID = QUuid(),
|
||||
|
|
@ -180,7 +180,7 @@ class Octree : public QObject {
|
|||
public:
|
||||
Octree(bool shouldReaverage = false);
|
||||
~Octree();
|
||||
|
||||
|
||||
/// Your tree class must implement this to create the correct element type
|
||||
virtual OctreeElement* createNewElement(unsigned char * octalCode = NULL) const = 0;
|
||||
|
||||
|
|
@ -209,8 +209,8 @@ public:
|
|||
OctreeElement* getOrCreateChildElementAt(float x, float y, float z, float s);
|
||||
|
||||
void recurseTreeWithOperation(RecurseOctreeOperation operation, void* extraData=NULL);
|
||||
|
||||
void recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
|
||||
|
||||
void recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
|
||||
const glm::vec3& point, void* extraData=NULL);
|
||||
|
||||
int encodeTreeBitstream(OctreeElement* node, OctreePacketData* packetData, OctreeElementBag& bag,
|
||||
|
|
@ -223,9 +223,9 @@ public:
|
|||
bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
|
||||
OctreeElement*& node, float& distance, BoxFace& face);
|
||||
|
||||
bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration,
|
||||
bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration,
|
||||
void** penetratedObject = NULL);
|
||||
|
||||
|
||||
bool findCapsulePenetration(const glm::vec3& start, const glm::vec3& end, float radius, glm::vec3& penetration);
|
||||
|
||||
// Note: this assumes the fileFormat is the HIO individual voxels code files
|
||||
|
|
@ -237,7 +237,7 @@ public:
|
|||
// reads voxels from square image with alpha as a Y-axis
|
||||
bool readFromSquareARGB32Pixels(const char *filename);
|
||||
bool readFromSchematicFile(const char* filename);
|
||||
|
||||
|
||||
// Octree does not currently handle its own locking, caller must use these to lock/unlock
|
||||
void lockForRead() { lock.lockForRead(); }
|
||||
void tryLockForRead() { lock.tryLockForRead(); }
|
||||
|
|
@ -249,13 +249,13 @@ public:
|
|||
|
||||
void copySubTreeIntoNewTree(OctreeElement* startNode, Octree* destinationTree, bool rebaseToRoot);
|
||||
void copyFromTreeIntoSubTree(Octree* sourceTree, OctreeElement* destinationNode);
|
||||
|
||||
|
||||
bool getShouldReaverage() const { return _shouldReaverage; }
|
||||
|
||||
void recurseNodeWithOperation(OctreeElement* node, RecurseOctreeOperation operation,
|
||||
void recurseNodeWithOperation(OctreeElement* node, RecurseOctreeOperation operation,
|
||||
void* extraData, int recursionCount = 0);
|
||||
|
||||
void recurseNodeWithOperationDistanceSorted(OctreeElement* node, RecurseOctreeOperation operation,
|
||||
|
||||
void recurseNodeWithOperationDistanceSorted(OctreeElement* node, RecurseOctreeOperation operation,
|
||||
const glm::vec3& point, void* extraData, int recursionCount = 0);
|
||||
|
||||
signals:
|
||||
|
|
@ -269,7 +269,7 @@ public slots:
|
|||
protected:
|
||||
void deleteOctalCodeFromTreeRecursion(OctreeElement* node, void* extraData);
|
||||
|
||||
int encodeTreeBitstreamRecursion(OctreeElement* node,
|
||||
int encodeTreeBitstreamRecursion(OctreeElement* node,
|
||||
OctreePacketData* packetData, OctreeElementBag& bag,
|
||||
EncodeBitstreamParams& params, int& currentEncodeLevel) const;
|
||||
|
||||
|
|
@ -277,20 +277,20 @@ protected:
|
|||
|
||||
OctreeElement* nodeForOctalCode(OctreeElement* ancestorNode, const unsigned char* needleCode, OctreeElement** parentOfFoundNode) const;
|
||||
OctreeElement* createMissingNode(OctreeElement* lastParentNode, const unsigned char* codeToReach);
|
||||
int readNodeData(OctreeElement *destinationNode, const unsigned char* nodeData,
|
||||
int readNodeData(OctreeElement *destinationNode, const unsigned char* nodeData,
|
||||
int bufferSizeBytes, ReadBitstreamToTreeParams& args);
|
||||
|
||||
|
||||
OctreeElement* _rootNode;
|
||||
|
||||
|
||||
bool _isDirty;
|
||||
bool _shouldReaverage;
|
||||
bool _stopImport;
|
||||
|
||||
/// Octal Codes of any subtrees currently being encoded. While any of these codes is being encoded, ancestors and
|
||||
/// Octal Codes of any subtrees currently being encoded. While any of these codes is being encoded, ancestors and
|
||||
/// descendants of them can not be deleted.
|
||||
std::set<const unsigned char*> _codesBeingEncoded;
|
||||
/// mutex lock to protect the encoding set
|
||||
pthread_mutex_t _encodeSetLock;
|
||||
QMutex _encodeSetLock;
|
||||
|
||||
/// Called to indicate that a OctreeElement is in the process of being encoded.
|
||||
void startEncoding(OctreeElement* node);
|
||||
|
|
@ -299,11 +299,11 @@ protected:
|
|||
/// Is the Octal Code currently being deleted?
|
||||
bool isEncoding(const unsigned char* codeBuffer);
|
||||
|
||||
/// Octal Codes of any subtrees currently being deleted. While any of these codes is being deleted, ancestors and
|
||||
/// Octal Codes of any subtrees currently being deleted. While any of these codes is being deleted, ancestors and
|
||||
/// descendants of them can not be encoded.
|
||||
std::set<const unsigned char*> _codesBeingDeleted;
|
||||
/// mutex lock to protect the deleting set
|
||||
pthread_mutex_t _deleteSetLock;
|
||||
QMutex _deleteSetLock;
|
||||
|
||||
/// Called to indicate that an octal code is in the process of being deleted.
|
||||
void startDeleting(const unsigned char* code);
|
||||
|
|
@ -313,13 +313,13 @@ protected:
|
|||
/// instead queued for later delete
|
||||
std::set<const unsigned char*> _codesPendingDelete;
|
||||
/// mutex lock to protect the deleting set
|
||||
pthread_mutex_t _deletePendingSetLock;
|
||||
QMutex _deletePendingSetLock;
|
||||
|
||||
/// Adds an Octal Code to the set of codes that needs to be deleted
|
||||
void queueForLaterDelete(const unsigned char* codeBuffer);
|
||||
/// flushes out any Octal Codes that had to be queued
|
||||
void emptyDeleteQueue();
|
||||
|
||||
|
||||
QReadWriteLock lock;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -14,12 +14,10 @@ GenericThread::GenericThread() :
|
|||
_stopThread(false),
|
||||
_isThreaded(false) // assume non-threaded, must call initialize()
|
||||
{
|
||||
pthread_mutex_init(&_mutex, 0);
|
||||
}
|
||||
|
||||
GenericThread::~GenericThread() {
|
||||
terminate();
|
||||
pthread_mutex_destroy(&_mutex);
|
||||
}
|
||||
|
||||
void GenericThread::initialize(bool isThreaded) {
|
||||
|
|
@ -32,30 +30,30 @@ void GenericThread::initialize(bool isThreaded) {
|
|||
void GenericThread::terminate() {
|
||||
if (_isThreaded) {
|
||||
_stopThread = true;
|
||||
pthread_join(_thread, NULL);
|
||||
pthread_join(_thread, NULL);
|
||||
_isThreaded = false;
|
||||
}
|
||||
}
|
||||
|
||||
void* GenericThread::threadRoutine() {
|
||||
while (!_stopThread) {
|
||||
|
||||
|
||||
// override this function to do whatever your class actually does, return false to exit thread early
|
||||
if (!process()) {
|
||||
break;
|
||||
}
|
||||
|
||||
// In non-threaded mode, this will break each time you call it so it's the
|
||||
|
||||
// In non-threaded mode, this will break each time you call it so it's the
|
||||
// callers responsibility to continuously call this method
|
||||
if (!_isThreaded) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (_isThreaded) {
|
||||
pthread_exit(0);
|
||||
pthread_exit(0);
|
||||
}
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
extern "C" void* GenericThreadEntry(void* arg) {
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
#define __shared__GenericThread__
|
||||
|
||||
#include <QtCore/QObject>
|
||||
#include <QMutex>
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
|
|
@ -41,15 +42,15 @@ public:
|
|||
protected:
|
||||
|
||||
/// Locks all the resources of the thread.
|
||||
void lock() { pthread_mutex_lock(&_mutex); }
|
||||
void lock() { _mutex.lock(); }
|
||||
|
||||
/// Unlocks all the resources of the thread.
|
||||
void unlock() { pthread_mutex_unlock(&_mutex); }
|
||||
void unlock() { _mutex.unlock(); }
|
||||
|
||||
bool isStillRunning() const { return !_stopThread; }
|
||||
|
||||
private:
|
||||
pthread_mutex_t _mutex;
|
||||
QMutex _mutex;
|
||||
|
||||
bool _stopThread;
|
||||
bool _isThreaded;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@
|
|||
//
|
||||
|
||||
#include <cstring>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
|
|
@ -35,7 +34,6 @@ Node::Node(const QUuid& uuid, char type, const HifiSockAddr& publicSocket, const
|
|||
_isAlive(true),
|
||||
_clockSkewUsec(0)
|
||||
{
|
||||
pthread_mutex_init(&_mutex, 0);
|
||||
}
|
||||
|
||||
Node::~Node() {
|
||||
|
|
@ -44,8 +42,6 @@ Node::~Node() {
|
|||
}
|
||||
|
||||
delete _bytesReceivedMovingAverage;
|
||||
|
||||
pthread_mutex_destroy(&_mutex);
|
||||
}
|
||||
|
||||
// Names of Node Types
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
|
||||
#include <QtCore/QDebug>
|
||||
#include <QtCore/QUuid>
|
||||
#include <QMutex>
|
||||
|
||||
#include "HifiSockAddr.h"
|
||||
#include "NodeData.h"
|
||||
|
|
@ -29,39 +30,39 @@ class Node {
|
|||
public:
|
||||
Node(const QUuid& uuid, char type, const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket);
|
||||
~Node();
|
||||
|
||||
|
||||
bool operator==(const Node& otherNode) const { return _uuid == otherNode._uuid; }
|
||||
bool operator!=(const Node& otherNode) const { return !(*this == otherNode); }
|
||||
|
||||
|
||||
char getType() const { return _type; }
|
||||
void setType(char type) { _type = type; }
|
||||
const char* getTypeName() const;
|
||||
|
||||
|
||||
const QUuid& getUUID() const { return _uuid; }
|
||||
void setUUID(const QUuid& uuid) { _uuid = uuid; }
|
||||
|
||||
|
||||
uint64_t getWakeMicrostamp() const { return _wakeMicrostamp; }
|
||||
void setWakeMicrostamp(uint64_t wakeMicrostamp) { _wakeMicrostamp = wakeMicrostamp; }
|
||||
|
||||
|
||||
uint64_t getLastHeardMicrostamp() const { return _lastHeardMicrostamp; }
|
||||
void setLastHeardMicrostamp(uint64_t lastHeardMicrostamp) { _lastHeardMicrostamp = lastHeardMicrostamp; }
|
||||
|
||||
|
||||
const HifiSockAddr& getPublicSocket() const { return _publicSocket; }
|
||||
void setPublicSocket(const HifiSockAddr& publicSocket);
|
||||
const HifiSockAddr& getLocalSocket() const { return _localSocket; }
|
||||
void setLocalSocket(const HifiSockAddr& localSocket);
|
||||
|
||||
|
||||
const HifiSockAddr* getActiveSocket() const { return _activeSocket; }
|
||||
|
||||
|
||||
void activatePublicSocket();
|
||||
void activateLocalSocket();
|
||||
|
||||
|
||||
NodeData* getLinkedData() const { return _linkedData; }
|
||||
void setLinkedData(NodeData* linkedData) { _linkedData = linkedData; }
|
||||
|
||||
|
||||
bool isAlive() const { return _isAlive; }
|
||||
void setAlive(bool isAlive) { _isAlive = isAlive; }
|
||||
|
||||
|
||||
void recordBytesReceived(int bytesReceived);
|
||||
float getAverageKilobitsPerSecond();
|
||||
float getAveragePacketsPerSecond();
|
||||
|
|
@ -71,20 +72,20 @@ public:
|
|||
|
||||
int getClockSkewUsec() const { return _clockSkewUsec; }
|
||||
void setClockSkewUsec(int clockSkew) { _clockSkewUsec = clockSkew; }
|
||||
|
||||
void lock() { pthread_mutex_lock(&_mutex); }
|
||||
|
||||
|
||||
void lock() { _mutex.lock(); }
|
||||
|
||||
/// returns false if lock failed, true if you got the lock
|
||||
bool trylock() { return (pthread_mutex_trylock(&_mutex) == 0); }
|
||||
void unlock() { pthread_mutex_unlock(&_mutex); }
|
||||
bool trylock() { return _mutex.tryLock(); }
|
||||
void unlock() { _mutex.unlock(); }
|
||||
|
||||
static void printLog(Node const&);
|
||||
|
||||
|
||||
private:
|
||||
// privatize copy and assignment operator to disallow Node copying
|
||||
Node(const Node &otherNode);
|
||||
Node& operator=(Node otherNode);
|
||||
|
||||
|
||||
char _type;
|
||||
QUuid _uuid;
|
||||
uint64_t _wakeMicrostamp;
|
||||
|
|
@ -97,7 +98,7 @@ private:
|
|||
bool _isAlive;
|
||||
int _pingMs;
|
||||
int _clockSkewUsec;
|
||||
pthread_mutex_t _mutex;
|
||||
QMutex _mutex;
|
||||
};
|
||||
|
||||
int unpackNodeId(unsigned char *packedData, uint16_t *nodeId);
|
||||
|
|
|
|||
Loading…
Reference in a new issue