mfxTraceU32 MFXTraceITT_BeginTask(mfxTraceStaticHandle *static_handle
,const char * //file_name
,mfxTraceU32 //line_num
,const char * //function_name
,mfxTraceChar* //category
,mfxTraceLevel level
,const char * task_name
,mfxTraceTaskHandle *handle
,const void * /*task_params*/)
{
if (!static_handle || !handle) return 1;
if (MFX_TRACE_LEVEL_API == level ||
MFX_TRACE_LEVEL_INTERNAL_VTUNE == level)
{
// cache string handle across task instances
if (NULL == static_handle->itt1.ptr)
{
static_handle->itt1.ptr = __itt_string_handle_create(task_name);
}
// task is traced
handle->itt1.uint32 = 1;
__itt_task_begin(GetDomain(), __itt_null, __itt_null,
(__itt_string_handle*)static_handle->itt1.ptr);
}
return 0;
}
void vtuneInit()
{
domain = __itt_domain_create("x265");
size_t length = sizeof(stringNames) / sizeof(const char *);
for (size_t i = 0; i < length; i++)
taskHandle[i] = __itt_string_handle_create(stringNames[i]);
}
static void ITT_init_strings() {
for ( int i = 0; i < NUM_STRINGS; ++i ) {
#if _WIN32||_WIN64
strings_for_itt[i].itt_str_handle = __itt_string_handle_createA( strings_for_itt[i].str );
#else
strings_for_itt[i].itt_str_handle = __itt_string_handle_create( strings_for_itt[i].str );
#endif
}
}
void RunExample()
{
__itt_task_begin(pD, __itt_null, __itt_null, __itt_string_handle_create(L"End of run"));
for(int i = 0; i < 50; ++i)
{
Example(i);
}
__itt_task_end(pD);
}
// ITT Metadata are sometimes useful for telling a bunch of tasks apart.
// Here, we have a function that accepts a parameter that, depending on its
// value, will cause the function to run quickly or slowly.
//
// If we trace this function without a parameter, all we will see is
// that one of these functions is really long, but won't know why.
//
// The __itt_metadata_add call below adds the actual index value to the trace
// In the GUI, we can then use this captured parameter to decide whether there
// is a correlation between the parameter and the function's duration.
//
__itt_domain* pD = __itt_domain_create(L"gpa_metadata_sample");
__itt_string_handle* pSH1 = __itt_string_handle_createA("Example");
__itt_string_handle* pSH2 = __itt_string_handle_create(L"index");
void Example(int index)
{
__itt_task_begin(pD, __itt_null, __itt_null, pSH1);
__itt_metadata_add(pD, __itt_null, pSH2, __itt_metadata_s32, 1, (void*)&index);
__itt_metadata_str_add(pD, __itt_null, pSH1, L"Example is running", 0);
if(index == 10)
{
Sleep(30);
}
else
{
namespace livre
{
#ifdef _ITT_DEBUG_
#include "ittnotify.h"
__itt_domain* ittTextureLoadDomain = __itt_domain_create("Texture Loading");
__itt_string_handle* ittTextureComputationTask =
__itt_string_handle_create("Texture loading computation");
__itt_string_handle* ittTextureLoadTask = __itt_string_handle_create("Texture loading task");
#endif // _ITT_DEBUG_
// Dont forget to apply cache policy after each traversal
class TextureLoaderVisitor : public RenderNodeVisitor
{
public:
TextureLoaderVisitor( DashTreePtr dashTree,
TextureCache& textureCache,
ProcessorInputPtr processorInput,
ProcessorOutputPtr processorOutput,
bool& needRedraw )
: RenderNodeVisitor( dashTree )
, _cache( textureCache )
, _input( processorInput )
, _output( processorOutput )
, _allLoaded( true ) // be optimistic; will be set to false on first
// non-loaded data during visit
, _synchronous( false )
, _needRedraw( needRedraw )
{}
void visit( DashRenderNode& renderNode, VisitState& state ) final;
bool isAllDataLoaded() const { return _allLoaded; }
bool isSynchronous() const { return _synchronous; }
void setSynchronous( const bool synchronous ) { _synchronous = synchronous;}
private:
TextureCache& _cache;
ProcessorInputPtr _input;
ProcessorOutputPtr _output;
bool _allLoaded;
bool _synchronous;
bool& _needRedraw;
};
class CollectVisiblesVisitor : public RenderNodeVisitor
{
public:
CollectVisiblesVisitor( DashTreePtr dashTree,
CacheIdSet& currentVisibleSet )
: RenderNodeVisitor( dashTree ),
currentVisibleSet_( currentVisibleSet ) {}
void visit( DashRenderNode& renderNode, VisitState& state ) final
{
const LODNode& lodNode = renderNode.getLODNode();
if( !renderNode.isInFrustum( ))
state.setVisitChild( false );
if( renderNode.isLODVisible( ))
{
currentVisibleSet_.insert( lodNode.getNodeId().getId( ));
state.setVisitChild( false );
}
}
private:
CacheIdSet& currentVisibleSet_;
};
TextureUploadProcessor::TextureUploadProcessor( DashTreePtr dashTree,
GLContextPtr shareContext,
GLContextPtr context,
ConstVolumeRendererParametersPtr vrParameters )
: GLContextTrait( context )
, _dashTree( dashTree )
, _shareContext( shareContext )
, _textureCache( GL_LUMINANCE8 )
, _currentFrameID( 0 )
, _threadOp( TO_NONE )
, _vrParameters( vrParameters )
, _allDataLoaded( false )
, _needRedraw( false )
{
setDashContext( dashTree->createContext());
}
const TextureCache& TextureUploadProcessor::getTextureCache() const
{
return _textureCache;
}
bool TextureUploadProcessor::initializeThreadRun_()
{
setName( "TexUp" );
_textureCache.setMaximumMemory( _vrParameters->maxGPUCacheMemoryMB * LB_1MB );
LBASSERT( getGLContext( ));
_shareContext->shareContext( getGLContext( ));
return DashProcessor::initializeThreadRun_();
}
bool TextureUploadProcessor::onPreCommit_( const uint32_t outputConnection LB_UNUSED )
{
const bool ret = _allDataLoaded;
_allDataLoaded = false;
return ret;
}
void TextureUploadProcessor::onPostCommit_( const uint32_t,
const CommitState state )
{
if( state != CS_NOCHANGE )
glFinish();
}
void TextureUploadProcessor::_loadData()
{
TextureLoaderVisitor loadVisitor( _dashTree, _textureCache,
processorInputPtr_, processorOutputPtr_,
_needRedraw );
loadVisitor.setSynchronous( _vrParameters->synchronousMode );
DFSTraversal traverser;
const RootNode& rootNode = _dashTree->getDataSource()->getVolumeInformation().rootNode;
traverser.traverse( rootNode, loadVisitor, _currentFrameID );
if( _vrParameters->synchronousMode )
_allDataLoaded = loadVisitor.isAllDataLoaded();
else
_allDataLoaded = true;
}
void TextureUploadProcessor::runLoop_()
{
_needRedraw = false;
if( GLContext::getCurrent() != getGLContext().get( ))
getGLContext()->makeCurrent();
processorInputPtr_->applyAll( CONNECTION_ID );
_checkThreadOperation();
#ifdef _ITT_DEBUG_
__itt_task_begin ( ittTextureLoadDomain, __itt_null, __itt_null, ittTextureComputationTask );
#endif //_ITT_DEBUG_
const DashRenderStatus& renderStatus = _dashTree->getRenderStatus();
if( renderStatus.getFrameID() != _currentFrameID )
{
_protectUnloading.clear();
CollectVisiblesVisitor collectVisibles( _dashTree,
_protectUnloading );
DFSTraversal traverser;
const RootNode& rootNode =
_dashTree->getDataSource()->getVolumeInformation().rootNode;
traverser.traverse( rootNode, collectVisibles, renderStatus.getFrameID( ));
_textureCache.setProtectList( _protectUnloading );
_currentFrameID = renderStatus.getFrameID();
}
_loadData();
processorOutputPtr_->commit( CONNECTION_ID );
#ifdef _ITT_DEBUG_
__itt_task_end( ittTextureLoadDomain );
#endif //_ITT_DEBUG_
}
void TextureUploadProcessor::_checkThreadOperation()
{
DashRenderStatus& renderStatus = _dashTree->getRenderStatus();
ThreadOperation op = renderStatus.getThreadOp();
if( op != _threadOp )
{
_threadOp = op;
renderStatus.setThreadOp( op );
processorOutputPtr_->commit( CONNECTION_ID );
}
if( _threadOp == TO_EXIT )
exit();
}
void TextureLoaderVisitor::visit( DashRenderNode& renderNode, VisitState& state )
{
const LODNode& lodNode = renderNode.getLODNode();
if( !lodNode.isValid( ))
return;
if( !renderNode.isInFrustum( ))
{
state.setVisitChild( false );
return;
}
if( !renderNode.isLODVisible( ))
return;
state.setVisitChild( false );
const ConstCacheObjectPtr texPtr = renderNode.getTextureObject();
if( texPtr->isLoaded( ))
return;
TextureObject& texture = _cache.getNodeTexture( lodNode.getNodeId().getId( ));
if( texture.isLoaded() )
{
renderNode.setTextureObject( &texture );
_output->commit( CONNECTION_ID );
return;
}
else
{
const ConstCacheObjectPtr textureData = renderNode.getTextureDataObject();
if( textureData->isLoaded( ))
{
#ifdef _ITT_DEBUG_
__itt_task_begin ( ittTextureLoadDomain, __itt_null, __itt_null,
ittTextureLoadTask );
#endif //_ITT_DEBUG_
TextureObject& lodTexture = _cache.getNodeTexture( lodNode.getNodeId().getId( ));
lodTexture.setTextureDataObject(
static_cast< const TextureDataObject * >( textureData.get() ) );
lodTexture.cacheLoad();
#ifdef _ITT_DEBUG_
__itt_task_end( ittTextureLoadDomain );
#endif //_ITT_DEBUG_
renderNode.setTextureObject( &lodTexture );
renderNode.setTextureDataObject( TextureDataObject::getEmptyPtr() );
_output->commit( CONNECTION_ID );
_needRedraw = true;
}
else
{
_allLoaded = false;
LBVERB << "Texture data not loaded:" << lodNode.getNodeId() << std::endl;
}
}
if( !isSynchronous( ))
// only in asynchronous mode
state.setBreakTraversal( _input->dataWaitingOnInput( CONNECTION_ID ));
}
}
Task *task(std::string Name) { return __itt_string_handle_create(Name.c_str()); }
#include "Module.h"
#include "Globals.h"
#include "HWInterface.h"
#include "HardwareConfig.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define ARDUINO_SIO_BUF_LEN 128
__itt_string_handle* pshPicThreadReadLoop = __itt_string_handle_create("Read Loop");
__itt_string_handle* pshPicThreadWriteLoop = __itt_string_handle_create("Write Loop");
__itt_string_handle* pshReadError = __itt_string_handle_create("Read Error");
__itt_string_handle* pshPicError = __itt_string_handle_create("Arduino Reported Error");
__itt_string_handle* pshHandleArduinoMessage = __itt_string_handle_create("Handle Arduino Msg");
__itt_string_handle* pshWaitForMoreData = __itt_string_handle_create("Wait for More Data");
__itt_string_handle* pshVersionRequest = __itt_string_handle_create("VersionRequest");
__itt_string_handle* pshPicWriteFile = __itt_string_handle_create("WriteFile");
__itt_string_handle* pshWriteIndex = __itt_string_handle_create("WriteIndex = ");
__itt_string_handle* pshReadIndex = __itt_string_handle_create("ReadIndex = ");
/**
