void File::poolAndNotify()
{
//http://stackoverflow.com/questions/5211993/using-read-with-inotify
while(sInotifyFD >= 0)
{
unsigned int avail;
ioctl(sInotifyFD, FIONREAD, &avail);
char buffer[avail];
SYSCALL_ALIAS_read(sInotifyFD, buffer, avail);
int offset = 0;
while(offset < (int) avail)
{
struct inotify_event *iEvent = (inotify_event *)(buffer + offset);
FileEvent event;
if(iEvent->mask & (IN_MODIFY))
event = FileEvent(iEvent->wd, IN_MODIFY);
else
continue;
sStaticLock.lock();
auto it = sListeners.find(event);
if(it == sListeners.end())
{
Debug::warning("File::poolAndNotify(): found no listener for ")(event.first)(". Ignoring notification.").endl();
sStaticLock.unlock();
continue;
}
sNotificationList.push_back(event);
sStaticLock.unlock();
// Debug::log("File::poolAndNotify(): wd: ")(event.first).endl();
offset += sizeof(inotify_event) + iEvent->len;
}
}
sStaticLock.lock();
sListeners.clear();
sStaticLock.unlock();
}
PRIVATE int ReturnEvent (HTTimer * timer, void * param, HTEventType type)
{
file_info * file = (file_info *) param;
if (timer != file->timer)
HTDEBUGBREAK("File timer %p not in sync\n" _ timer);
HTTRACE(PROT_TRACE, "HTLoadFile.. Continuing %p with timer %p\n" _ file _ timer);
/*
** Delete the timer
*/
HTTimer_delete(file->timer);
file->timer = NULL;
/*
** Now call the event again
*/
return FileEvent(INVSOC, file, HTEvent_READ);
}
PUBLIC int HTLoadFile (SOCKET soc, HTRequest * request)
{
file_info *file; /* Specific access information */
HTNet * net = HTRequest_net(request);
HTParentAnchor * anchor = HTRequest_anchor(request);
HTTRACE(PROT_TRACE, "HTLoadFile.. Looking for `%s\'\n" _
HTAnchor_physical(anchor));
if ((file = (file_info *) HT_CALLOC(1, sizeof(file_info))) == NULL)
HT_OUTOFMEM("HTLoadFILE");
file->state = FS_BEGIN;
file->net = net;
HTNet_setContext(net, file);
HTNet_setEventCallback(net, FileEvent);
HTNet_setEventParam(net, file); /* callbacks get http* */
return FileEvent(soc, file, HTEvent_BEGIN); /* get it started - ops is ignored */
}
void DisplayProfileData( const TMap< FString, TSharedPtr< struct FProfiledFileStatsFileBase > >& InProfileData )
{
TArray< TSharedPtr<FProfiledFileStatsFileBase> > ProfileData;
InProfileData.GenerateValueArray( ProfileData );
// Single root data is required for bar visualizer to work properly
TSharedPtr< FVisualizerEvent > RootEvent( new FVisualizerEvent( 0.0, 1.0, 0.0, 0, TEXT("I/O") ) );
// Calculate Start time first
double StartTimeMs = FPlatformTime::Seconds() * 1000.0; // All timings happened before now
double EndTimeMs = 0.0;
for( int32 Index = 0; Index < ProfileData.Num(); Index++ )
{
TSharedPtr<FProfiledFileStatsFileBase> FileStat = ProfileData[ Index ];
double FileDurationMs = 0.0;
for( int32 ChildIndex = 0; ChildIndex < FileStat->Children.Num(); ChildIndex++ )
{
TSharedPtr<FProfiledFileStatsOp> FileOpStat = FileStat->Children[ ChildIndex ];
if( FileOpStat->Duration > 0.0 )
{
StartTimeMs = FMath::Min( FileOpStat->StartTime, StartTimeMs );
EndTimeMs = FMath::Max( FileOpStat->StartTime + FileOpStat->Duration, EndTimeMs );
FileDurationMs += FileOpStat->Duration;
}
}
// Create an event for each of the files
TSharedPtr< FVisualizerEvent > FileEvent( new FVisualizerEvent( 0.0, 1.0, FileDurationMs, Index, FileStat->Name ) );
FileEvent->ParentEvent = RootEvent;
RootEvent->Children.Add( FileEvent );
}
const double TotalTimeMs = EndTimeMs - StartTimeMs;
RootEvent->DurationMs = TotalTimeMs;
for( int32 FileIndex = 0; FileIndex < ProfileData.Num(); FileIndex++ )
{
TSharedPtr<FProfiledFileStatsFileBase> FileStat = ProfileData[ FileIndex ];
TSharedPtr<FVisualizerEvent> FileEvent( RootEvent->Children[ FileIndex ] );
for( int32 ChildIndex = 0; ChildIndex < FileStat->Children.Num(); ChildIndex++ )
{
TSharedPtr<FProfiledFileStatsOp> FileOpStat = FileStat->Children[ ChildIndex ];
if( FileOpStat->Duration > 0.0 )
{
FString EventName;
switch( FileOpStat->Type )
{
case FProfiledFileStatsOp::Tell:
EventName = TEXT("Tell"); break;
case FProfiledFileStatsOp::Seek:
EventName = TEXT("Seek"); break;
case FProfiledFileStatsOp::Read:
EventName = FString::Printf( TEXT("Read (%lld)"), FileOpStat->Bytes ); break;
case FProfiledFileStatsOp::Write:
EventName = FString::Printf( TEXT("Write (%lld)"), FileOpStat->Bytes ); break;
case FProfiledFileStatsOp::Size:
EventName = TEXT("Size"); break;
case FProfiledFileStatsOp::OpenRead:
EventName = TEXT("OpenRead"); break;
case FProfiledFileStatsOp::OpenWrite:
EventName = TEXT("OpenWrite"); break;
case FProfiledFileStatsOp::Exists:
EventName = TEXT("Exists"); break;
case FProfiledFileStatsOp::Delete:
EventName = TEXT("Delete"); break;
case FProfiledFileStatsOp::Move:
EventName = TEXT("Move"); break;
case FProfiledFileStatsOp::IsReadOnly:
EventName = TEXT("IsReadOnly"); break;
case FProfiledFileStatsOp::SetReadOnly:
EventName = TEXT("SetReadOnly"); break;
case FProfiledFileStatsOp::GetTimeStamp:
EventName = TEXT("GetTimeStamp"); break;
case FProfiledFileStatsOp::SetTimeStamp:
EventName = TEXT("SetTimeStamp"); break;
case FProfiledFileStatsOp::Create:
EventName = TEXT("Create"); break;
case FProfiledFileStatsOp::Copy:
EventName = TEXT("Copy"); break;
case FProfiledFileStatsOp::Iterate:
EventName = TEXT("Iterate"); break;
default:
EventName = TEXT("Unknown"); break;
}
const double StartTime = ( FileOpStat->StartTime - StartTimeMs ) / TotalTimeMs;
const double DurationTime = FileOpStat->Duration / TotalTimeMs;
TSharedPtr<FVisualizerEvent> ChildEvent( new FVisualizerEvent( StartTime, DurationTime, FileOpStat->Duration, FileIndex, EventName ) );
ChildEvent->ParentEvent = FileEvent;
FileEvent->Children.Add( ChildEvent );
}
}
}
static FName TaskGraphModule(TEXT("TaskGraph"));
if (FModuleManager::Get().IsModuleLoaded(TaskGraphModule))
{
IProfileVisualizerModule& ProfileVisualizer = FModuleManager::GetModuleChecked<IProfileVisualizerModule>(TaskGraphModule);
ProfileVisualizer.DisplayProfileVisualizer( RootEvent, TEXT("I/O") );
}
}