profiler.cpp

#include <ITA/simulation_scheduler/profiler/profiler.h>

// simulation scheduler includes
#include "../src/ITA/simulation_scheduler/profiler/profiler_key.h"
#include "../src/ITA/simulation_scheduler/profiler/profiler_data.h"
#include "../src/ITA/simulation_scheduler/profiler/profiler_thread_storage.h"
#include <ITA/simulation_scheduler/utils/utils.h>
#include <ITA/simulation_scheduler/profiler/profiler_types.h>

// std includes
#include <ostream>
#include <stack>
#include <thread>
#include <unordered_map>
#include <sstream>
#include <algorithm>
#include <mutex>

// ITA includes
#include <ITAClock.h>
#include <ITAStopWatch.h>

// misc includes
#include <libjson.h>
#include <VistaBase/VistaTimeUtils.h>

#ifdef WITH_PROFILER

namespace ITA
{
	namespace simulation_scheduler
	{
		namespace profiler
		{
			class ProfilerInstance;

		#if _MSC_VER >= 1900 && FALSE
		#define MAGIC_STATICS
		#define THREAD_LOCAL thread_local
		#else
		#define THREAD_LOCAL __declspec( thread )
		#endif

			static THREAD_LOCAL SProfilerThreadStorage* THIS_THREAD = nullptr;

			///
			/// \brief Profiler class.
			///
			/// This singleton class keeps all profiler data.
			/// It should be used through the public interface defined in profiler.h.
			///
			/// It keeps a record of opened sections and saves the results of closed sections and event counts.
			///
			/// This implementation was inspired by [easy_profiler by yse](https://github.com/yse/easy_profiler).
			///
			class CProfiler
			{
			public:
				///
				/// \brief Get the  instance.
				/// \note This implementation is thread safe.
				///
				static CProfiler& getInstance ( );

				///
				/// \brief Add an event to the profiler.
				/// \param sName name of the section.
				/// \param sFunctionName name of the function that started the section.
				/// \param sFile name of the file in which the section was started.
				/// 
				void addEventCount ( const std::string& sName, const std::string& sFunctionName, const std::string& sFile )
				{
					if ( !m_bEnabled )
						return;

					if ( THIS_THREAD == nullptr )
						registerThread ( );

					THIS_THREAD->m_mEventCount [{sName, sFunctionName, sFile, std::this_thread::get_id ( )}]++;
				}

				///
				/// \brief Start a section.
				///
				/// This function adds an open section to the stack for the current thread.
				/// \param oSection the section object to add to the profiler.
				/// \param sName name of the section.
				/// \param sFunctionName name of the function that started the section.
				/// \param sFile name of the file in which the section was started.
				/// 
				void startSection ( CSection& oSection,
									const std::string& sName,
									const std::string& sFunctionName,
									const std::string& sFile )
				{
					if ( !m_bEnabled )
						return;

					if ( THIS_THREAD == nullptr )
						registerThread ( );

					oSection.start ( );

					THIS_THREAD->m_msOpenSections [std::this_thread::get_id ( )].push ( { {sName, sFunctionName, sFile, std::this_thread::get_id ( )}, oSection } );
				}

				///
				/// \brief End the last opened section in the current thread.
				/// 
				void endSection ( )
				{
					if ( !m_bEnabled )
						return;

					if ( THIS_THREAD == nullptr )
						registerThread ( );

					const auto iterator = THIS_THREAD->m_msOpenSections.find ( std::this_thread::get_id ( ) );
					if ( iterator != THIS_THREAD->m_msOpenSections.end ( ) )
					{
						auto& openSections = iterator->second;
						if ( !openSections.top ( ).second.get ( ).finished ( ) )
							openSections.top ( ).second.get ( ).end ( );

						THIS_THREAD->m_mSections [openSections.top ( ).first].addSection ( openSections.top ( ).second );

						openSections.pop ( );
					}
				}

				///
				/// \brief End all open sections for all threads.
				/// 
				void endAllSections ( )
				{
					std::lock_guard<std::mutex> lock ( m_oMutex );

					for ( auto& thread : m_mThreadStorage )
					{
						for ( auto& key : thread.second.m_msOpenSections )
						{
							while ( !key.second.empty ( ) )
							{
								auto& openSections = key.second;

								if ( !openSections.top ( ).second.get ( ).finished ( ) )
									openSections.top ( ).second.get ( ).end ( );

								thread.second.m_mSections [openSections.top ( ).first].addSection ( openSections.top ( ).second );

								openSections.pop ( );
							}
						}
					}
				}

				///
				/// \brief Name the current thread.
				///
				/// Only the first invocation of this has an effect.
				///
				void nameThread ( const std::string& sName )
				{
					std::lock_guard<std::mutex> lock ( m_oMutex );
					if ( m_mThreadNames.find ( std::this_thread::get_id ( ) ) == m_mThreadNames.end ( ) )
						m_mThreadNames [std::this_thread::get_id ( )] = sName;
				}

				///
				/// \brief Add a value to the profiler.
				///
				/// The value must be of type: bool, char, int, float, double, string.
				/// \param sName name of the value.
				/// \param value the value to be saved in the profiler.
				/// \param sFunctionName name of the function that issued the event.
				/// \param sFile name of the file in which the event was issued.
				///
				void addValue ( const std::string& sName, const ValueData& value, const std::string& sFunctionName, const std::string& sFile )
				{
					if ( !m_bEnabled )
						return;

					if ( THIS_THREAD == nullptr )
						registerThread ( );

					THIS_THREAD->m_mValues [{sName, sFunctionName, sFile, std::this_thread::get_id ( )}].addValue ( value );
				}

				///
				/// \brief Register a thread with a thread storage.
				/// 
				void registerThread ( )
				{
					THIS_THREAD = &getThreadStorageReferenceById ( std::this_thread::get_id ( ) );
				}

				///
				/// \brief Thread save access to thread storage map.
				/// \param oThreadId ID of the thread storage to be retrieved.
				/// \return reference to the desired thread storage.
				/// 
				SProfilerThreadStorage& getThreadStorageReferenceById ( std::thread::id oThreadId )
				{
					std::lock_guard<std::mutex> lock ( m_oMutex );

					return m_mThreadStorage [oThreadId];
				}

				///
				/// \brief Parses the profiler data as a JSON file.
				/// \return a string stream containing the profiler data as a JSON file.
				/// 
				std::stringstream profilerToJSON ( )
				{
					JSONNode jnRoot;
					jnRoot.set_name ( "Profiler" );

					jnRoot.push_back ( JSONNode ( "Time Unit", "us - 1e-6" ) );

					jnRoot.push_back ( JSONNode ( "CPU Frequency", ITAClock::getDefaultClock ( )->getFrequency ( ) ) );

					JSONNode jnSection;
					jnSection.set_name ( "Profile Sections" );

					JSONNode jnEventCount;
					jnEventCount.set_name ( "Profile EventCounts" );

					JSONNode jnValue;
					jnValue.set_name ( "Profile Values" );

					// Disable profiling while we write to file.
					m_bEnabled = false;

					// Wait a bit for sections to end
					VistaTimeUtils::Sleep ( 50 );

					// Now we force all sections to end.
					endAllSections ( );

					// Lock the mutex as we want thread safe access to the thread storage.
					std::lock_guard<std::mutex> lock ( m_oMutex );

					ITAStopWatch swSection, swEvent, swValue, swThread;

					for ( const auto& threadStorage : m_mThreadStorage )
					{
						swThread.start ( );
						for ( const auto& sectionPair : threadStorage.second.m_mSections )
						{
							swSection.start ( );
							jnSection.push_back ( profileSectionToJSON ( sectionPair, m_mThreadNames ) );
							swSection.stop ( );
						}

						for ( const auto& eventCountPair : threadStorage.second.m_mEventCount )
						{
							swEvent.start ( );
							jnEventCount.push_back ( profileEventCountToJSON ( eventCountPair, m_mThreadNames ) );
							swEvent.stop ( );
						}

						for ( const auto& valuePair : threadStorage.second.m_mValues )
						{
							swValue.start ( );
							jnValue.push_back ( profileValuesToJSON ( valuePair, m_mThreadNames ) );
							swValue.stop ( );
						}
						swThread.stop ( );
					}

					jnRoot.push_back ( JSONNode ( "Section SW", swSection.ToString ( ) ) );
					jnRoot.push_back ( JSONNode ( "Event SW", swEvent.ToString ( ) ) );
					jnRoot.push_back ( JSONNode ( "Value SW", swValue.ToString ( ) ) );
					jnRoot.push_back ( JSONNode ( "Thread SW", swThread.ToString ( ) + ", sum=" + std::to_string ( swThread.sum ( ) ) ) );

					jnRoot.push_back ( jnSection );

					jnRoot.push_back ( jnEventCount );

					jnRoot.push_back ( jnValue );

					// Reenable profiling
					m_bEnabled = true;

					std::stringstream ss;
					ss << jnRoot.write ( );
					return ss;
				}

				///
				/// \brief Parses the given eventCount pair to a JSON Node.
				/// \param eventCountPair pair with the Key and the ProfileEventCount to be parsed.
				/// \param mThreadNames map, containing the names of the threads.
				/// \return a JSON Node with the data of the given eventCount pair.
				/// 
				static JSONNode profileEventCountToJSON ( const std::pair<ProfilerKey, ProfileEventCount>& eventCountPair,
														  const std::unordered_map<std::thread::id, std::string>& mThreadNames )
				{
					std::string sThreadName;

					const auto threadNameIterator = mThreadNames.find ( eventCountPair.first.iThreadId );

					if ( threadNameIterator != mThreadNames.end ( ) )
						sThreadName = threadNameIterator->second;

					JSONNode jnRoot;
					if ( !sThreadName.empty ( ) )
						jnRoot.set_name ( "[" + eventCountPair.first.sFunction + "][" + eventCountPair.first.sName + "][" + sThreadName + "]" );
					else
						jnRoot.set_name ( "[" + eventCountPair.first.sFunction + "][" + eventCountPair.first.sName + "][" + std::to_string ( eventCountPair.first.iThreadId.hash ( ) ) + "]" );

					jnRoot.push_back ( JSONNode ( "Name", eventCountPair.first.sName ) );
					jnRoot.push_back ( JSONNode ( "File Name", eventCountPair.first.sFile ) );
					jnRoot.push_back ( JSONNode ( "Function Name", eventCountPair.first.sFunction ) );
					jnRoot.push_back ( JSONNode ( "Thread Id", eventCountPair.first.iThreadId.hash ( ) ) );

					if ( !sThreadName.empty ( ) )
						jnRoot.push_back ( JSONNode ( "Thread Name", sThreadName ) );

					jnRoot.push_back ( JSONNode ( "Count", eventCountPair.second.vTimeStamps.size ( ) ) );

					std::vector<double> vdTimeStamps ( eventCountPair.second.vTimeStamps.size ( ) );

					std::transform ( eventCountPair.second.vTimeStamps.begin ( ),
									 eventCountPair.second.vTimeStamps.end ( ),
									 vdTimeStamps.begin ( ),
									 [] ( const double& time ) -> double
					{
						return time * 1e6;
					} );

					/*JSONNode jnTimeStampArray ( JSON_ARRAY );
					jnTimeStampArray.set_name ( "TimeStamps" );
					jnTimeStampArray.reserve ( vdTimeStamps.size ( ) );
					JSONNode jnData ( JSON_NUMBER );

					for ( const auto& timeStamp : vdTimeStamps )
					{
						jnData = timeStamp;
						jnTimeStampArray.push_back ( jnData );
					}

					jnRoot.push_back ( jnTimeStampArray );*/

					jnRoot.push_back ( JSONNode ( "Time Stamps", utils::DataTypeUtils::convertToString ( vdTimeStamps, 8, "," ) ) );

					return jnRoot;
				}

				///
				/// \brief Parses the given section pair to a JSON Node.
				///
				/// This function also calculates and add the min, max, mean, variance and standard deviation of the section to the JSON Node.
				/// \param sectionPair pair with the Key and the ProfileSection to be parsed.
				/// \param mThreadNames map, containing the names of the threads.
				/// \return a JSON Node with the data of the given section pair.
				/// 
				static JSONNode profileSectionToJSON ( const std::pair<ProfilerKey, ProfileSection>& sectionPair,
													   const std::unordered_map<std::thread::id, std::string>& mThreadNames )
				{
					std::string sThreadName;

					const auto threadNameIterator = mThreadNames.find ( sectionPair.first.iThreadId );

					if ( threadNameIterator != mThreadNames.end ( ) )
						sThreadName = threadNameIterator->second;

					JSONNode jnRoot;
					if ( !sThreadName.empty ( ) )
						jnRoot.set_name ( "[" + sectionPair.first.sFunction + "][" + sectionPair.first.sName + "][" + sThreadName + "]" );
					else
						jnRoot.set_name ( "[" + sectionPair.first.sFunction + "][" + sectionPair.first.sName + "][" + std::to_string ( sectionPair.first.iThreadId.hash ( ) ) + "]" );

					jnRoot.push_back ( JSONNode ( "Name", sectionPair.first.sName ) );
					jnRoot.push_back ( JSONNode ( "File Name", sectionPair.first.sFile ) );
					jnRoot.push_back ( JSONNode ( "Function Name", sectionPair.first.sFunction ) );
					jnRoot.push_back ( JSONNode ( "Thread Id", sectionPair.first.iThreadId.hash ( ) ) );

					if ( !sThreadName.empty ( ) )
						jnRoot.push_back ( JSONNode ( "Thread Name", sThreadName ) );

					jnRoot.push_back ( JSONNode ( "Count", sectionPair.second.vpStartEndTimes.size ( ) ) );

					std::vector<double> vdDeltaTime ( sectionPair.second.vpStartEndTimes.size ( ) );
					std::vector<double> vdStartTime ( sectionPair.second.vpStartEndTimes.size ( ) );
					std::vector<double> vdEndTime ( sectionPair.second.vpStartEndTimes.size ( ) );

					std::transform ( sectionPair.second.vpStartEndTimes.begin ( ),
									 sectionPair.second.vpStartEndTimes.end ( ),
									 vdDeltaTime.begin ( ),
									 [] ( const std::pair<double, double>& interval ) -> double
					{
						return ( interval.second - interval.first ) * 1e6;
					} );

					std::transform ( sectionPair.second.vpStartEndTimes.begin ( ),
									 sectionPair.second.vpStartEndTimes.end ( ),
									 vdStartTime.begin ( ),
									 [] ( const std::pair<double, double>& interval ) -> double
					{
						return interval.first * 1e6;
					} );

					std::transform ( sectionPair.second.vpStartEndTimes.begin ( ),
									 sectionPair.second.vpStartEndTimes.end ( ),
									 vdEndTime.begin ( ),
									 [] ( const std::pair<double, double>& interval ) -> double
					{
						return interval.second * 1e6;
					} );

					jnRoot.push_back ( JSONNode ( "Min", *std::min_element ( vdDeltaTime.begin ( ), vdDeltaTime.end ( ) ) ) );
					jnRoot.push_back ( JSONNode ( "Max", *std::max_element ( vdDeltaTime.begin ( ), vdDeltaTime.end ( ) ) ) );
					jnRoot.push_back ( JSONNode ( "Mean", utils::Statistics::calculateMean ( vdDeltaTime ) ) );
					jnRoot.push_back ( JSONNode ( "Variance", utils::Statistics::calculateVariance ( vdDeltaTime ) ) );
					jnRoot.push_back ( JSONNode ( "StdDeviation", utils::Statistics::calculateStandardDeviation ( vdDeltaTime ) ) );

					/*JSONNode jnStartTimeArray ( JSON_ARRAY );
					jnStartTimeArray.set_name ( "Start Times" );
					jnStartTimeArray.reserve ( vdStartTime.size ( ) );
					JSONNode jnData( JSON_NUMBER );

					for ( const auto& timeStamp : vdStartTime )
					{
						jnData = timeStamp;
						jnStartTimeArray.push_back ( jnData );
					}

					jnRoot.push_back ( jnStartTimeArray );

					JSONNode jnEndTimeArray ( JSON_ARRAY );
					jnEndTimeArray.set_name ( "End Times" );
					jnEndTimeArray.reserve ( vdStartTime.size ( ) );

					for ( const auto& timeStamp : vdEndTime )
					{
						jnData = timeStamp;
						jnEndTimeArray.push_back ( jnData );
					}

					jnRoot.push_back ( jnEndTimeArray );*/

					jnRoot.push_back ( JSONNode ( "Start Times", utils::DataTypeUtils::convertToString ( vdStartTime, 8, "," ) ) );
					jnRoot.push_back ( JSONNode ( "End Times", utils::DataTypeUtils::convertToString ( vdEndTime, 8, "," ) ) );

					return jnRoot;
				}

				///
				/// \brief Parses the given ProfileValue pair to a JSON Node.
				/// \param valuePair pair with the Key and the ProfileEventCount to be parsed.
				/// \param mThreadNames map, containing the names of the threads.
				/// \return a JSON Node with the data of the given ProfileValue pair.
				/// 
				static JSONNode profileValuesToJSON ( const std::pair<ProfilerKey, ProfileValue>& valuePair,
													  const std::unordered_map<std::thread::id, std::string>& mThreadNames )
				{
					std::string sThreadName;

					const auto threadNameIterator = mThreadNames.find ( valuePair.first.iThreadId );

					if ( threadNameIterator != mThreadNames.end ( ) )
						sThreadName = threadNameIterator->second;

					JSONNode jnRoot;
					if ( !sThreadName.empty ( ) )
						jnRoot.set_name ( "[" + valuePair.first.sFunction + "][" + valuePair.first.sName + "][" + sThreadName + "]" );
					else
						jnRoot.set_name ( "[" + valuePair.first.sFunction + "][" + valuePair.first.sName + "][" + std::to_string ( valuePair.first.iThreadId.hash ( ) ) + "]" );

					jnRoot.push_back ( JSONNode ( "Name", valuePair.first.sName ) );
					jnRoot.push_back ( JSONNode ( "File Name", valuePair.first.sFile ) );
					jnRoot.push_back ( JSONNode ( "Function Name", valuePair.first.sFunction ) );
					jnRoot.push_back ( JSONNode ( "Thread Id", valuePair.first.iThreadId.hash ( ) ) );

					if ( !sThreadName.empty ( ) )
						jnRoot.push_back ( JSONNode ( "Thread Name", sThreadName ) );

					jnRoot.push_back ( JSONNode ( "Count", valuePair.second.size ( ) ) );

					std::tuple<JSONNode, JSONNode> valueNodes;

					// store the tim stamps
					switch ( valuePair.second.getDataType ( ) )
					{
						case DataType::Bool:
							valueNodes = valueDataToJSON<bool> ( valuePair.second );
							break;
						case DataType::Char:
							valueNodes = valueDataToJSON<char> ( valuePair.second );
							break;
						case DataType::Int:
							valueNodes = valueDataToJSON<int> ( valuePair.second );
							break;
						case DataType::UnsignedInt:
							valueNodes = valueDataToJSON<unsigned int> ( valuePair.second );
							break;
						case DataType::UnsignedLongInt:
							valueNodes = valueDataToJSON<unsigned long int> ( valuePair.second );
							break;
						case DataType::Float:
							valueNodes = valueDataToJSON<float> ( valuePair.second );
							break;
						case DataType::Double:
							valueNodes = valueDataToJSON<double> ( valuePair.second );
							break;
						default:
							ITA_EXCEPT_INVALID_PARAMETER ( "Unkown data type" );
					}

					jnRoot.push_back ( std::get<0> ( valueNodes ) );
					jnRoot.push_back ( std::get<1> ( valueNodes ) );

					return jnRoot;
				}

				///
				/// \brief Parse a ProfileValue to two JSONNodes for data and time stamp.
				/// \tparam T type of the desired ProfileValue.
				/// \param oProfileValue the ProfileValue to be parsed.
				/// \return returns a tuple with the JSONNode for the time stamp and data. 
				/// 
				template<class T>
				static std::tuple<JSONNode, JSONNode> valueDataToJSON ( const ProfileValue& oProfileValue )
				{
					std::vector<std::pair<T, double>> dataVector = oProfileValue.getData<T> ( );

					/*JSONNode jnTimeStampArray ( JSON_ARRAY );
					jnTimeStampArray.set_name ( "TimeStamps" );
					jnTimeStampArray.reserve ( dataVector.size ( ) );
					JSONNode jnDataArray ( JSON_ARRAY );
					jnDataArray.set_name ( "Data" );
					jnDataArray.reserve ( dataVector.size ( ) );
					JSONNode jnData ( JSON_NUMBER );

					for ( const auto& data : dataVector )
					{
						jnData = data.first;
						jnDataArray.push_back ( jnData );
						jnData = data.second;
						jnTimeStampArray.push_back ( jnData );
					}*/

					std::vector<T> vTData ( dataVector.size ( ) );
					std::vector<double> vdTimeStamps ( dataVector.size ( ) );

					std::transform ( dataVector.begin ( ),
									 dataVector.end ( ),
									 vTData.begin ( ),
									 [] ( const std::pair<T, double>& p ) -> T
					{
						return p.first;
					} );

					std::transform ( dataVector.begin ( ),
									 dataVector.end ( ),
									 vdTimeStamps.begin ( ),
									 [] ( const std::pair<T, double>& p ) -> double
					{
						return p.second;
					} );

					JSONNode jnTimeStampArray ( "Time Stamps", utils::DataTypeUtils::convertToString ( vdTimeStamps, 8, "," ) );
					JSONNode jnDataArray ( "Data", utils::DataTypeUtils::convertToString ( vTData, 8, "," ) );

					return std::make_pair ( jnTimeStampArray, jnDataArray );
				}

			private:

			#ifndef MAGIC_STATICS
				friend ProfilerInstance;
			#endif

				CProfiler ( ) = default;

				~CProfiler ( ) = default;

				CProfiler ( const CProfiler& other ) = delete;

				CProfiler& operator=( const CProfiler& other ) = delete;

				///
				/// \brief Map, storing the thread storage.
				/// 
				std::unordered_map<std::thread::id, SProfilerThreadStorage> m_mThreadStorage;

				///
				/// \brief Map, storing the names of named threads.
				/// 
				std::unordered_map<std::thread::id, std::string> m_mThreadNames;

				///
				/// \brief Mutex for write access.
				/// 
				std::mutex m_oMutex;

				///
				/// \brief True, if profiling is activated.
				///
				/// This is used to stop profiling while we save data.
				/// 
				bool m_bEnabled = true;
			};

			class ProfilerInstance final
			{
				friend CProfiler;
				CProfiler instance;
			} PROFILE_MANAGER;

			CProfiler& CProfiler::getInstance ( )
			{
			#ifdef MAGIC_STATICS
				static CProfiler instance;
				return instance;
			#else				
				return PROFILE_MANAGER.instance;
			#endif
			}

			void CSection::start ( )
			{
				m_dBegin = ITAClock::getDefaultClock ( )->getTime ( );
			}

			void CSection::end ( )
			{
				m_dEnd = ITAClock::getDefaultClock ( )->getTime ( );
			}

			bool CSection::finished ( ) const
			{
				return m_dEnd >= m_dBegin;
			}

			CSection::~CSection ( )
			{
				if ( !finished ( ) )
					profiler::endSection ( );
			}

			void startSection ( CSection& oSection,
								const std::string& sName,
								const std::string& sFunctionName,
								const std::string& sFile )
			{
				CProfiler::getInstance ( ).startSection ( oSection, sName, sFunctionName, sFile );
			}

			void endSection ( )
			{
				CProfiler::getInstance ( ).endSection ( );
			}

			void endAllSections ( )
			{
				CProfiler::getInstance ( ).endAllSections ( );
			}

			void addEventCount ( const std::string& sName, const std::string& sFunctionName, const std::string& sFile )
			{
				CProfiler::getInstance ( ).addEventCount ( sName, sFunctionName, sFile );
			}

			void storeValue ( const std::string& sName, const ValueData& valueData, const std::string& sFunctionName, const std::string& sFile )
			{
				CProfiler::getInstance ( ).addValue ( sName, valueData, sFunctionName, sFile );
			}

			void nameThread ( const std::string& sName )
			{
				CProfiler::getInstance ( ).nameThread ( sName );
			}

			std::stringstream profilerToJSON ( )
			{
				return CProfiler::getInstance ( ).profilerToJSON ( );
			}
		} // namespace profiler

		void storeProfilerData ( const std::string& sProfilerFileName )
		{
		#ifdef WITH_PROFILER
			PROFILER_EVENT_COUNT ( "STOP" );

			std::ofstream myProfile;
			myProfile.open ( sProfilerFileName );
			myProfile << profiler::profilerToJSON ( ).str ( );
			myProfile.close ( );
		#endif
		}
	} // namespace simulation_scheduler
} // namespace ITA

#endif