ECR #333755 - Added two HSA samples: MatrixMultiplication, MatrixTranspose

[git-p4: depot-paths = "//depot/stg/hsa/drivers/hsa/runtime/": change = 1124951]

samples/common/hsatimer.cpp

@@ -0,0 +1,190 @@
+#include "hsatimer.h"
+
+PerfTimer::PerfTimer()
+{
+    freq_in_100mhz = MeasureTSCFreqHz();
+}
+
+PerfTimer::~PerfTimer()
+{
+	while(!_timers.empty())
+	{
+		Timer *temp = _timers.back();
+		_timers.pop_back();
+		delete temp;
+	}
+}
+
+//a new cretaed timer instantance index will be returned
+int PerfTimer::CreateTimer()
+{
+    Timer *newTimer = new Timer;
+	newTimer->_start = 0;
+	newTimer->_clocks = 0;
+
+#ifdef _WIN32
+    QueryPerformanceFrequency((LARGE_INTEGER*)&newTimer->_freq);       
+#else
+	newTimer->_freq = (long long)1.0E3;
+#endif
+
+	/* Push back the address of new Timer instance created */
+	_timers.push_back(newTimer);
+	return (int)(_timers.size() - 1);
+}
+
+int PerfTimer::StartTimer(int index)
+{
+	if(index >= (int)_timers.size())
+	{
+		Error("Cannot reset timer. Invalid handle.");
+		return HSA_FAILURE;
+	}
+	
+#ifdef _WIN32
+        // General Windows timing method
+       #ifndef _AMD
+	long long tmpStart;
+	QueryPerformanceCounter((LARGE_INTEGER*)&(tmpStart));
+	_timers[index]->_start = (double)tmpStart;
+       #else
+       // AMD Windows timing method      
+
+       #endif
+	   
+#else
+       // General Linux timing method
+      #ifndef _AMD
+	struct timeval s;
+	gettimeofday(&s, 0);
+	_timers[index]->_start = s.tv_sec * 1.0E3 + ((double)(s.tv_usec / 1.0E3)); 
+       #else
+
+       // AMD timing method
+
+	unsigned int unused;
+	_timers[index]->_start = __rdtscp(&unused);
+
+       #endif
+	   
+#endif
+
+	return HSA_SUCCESS;
+}
+
+
+int PerfTimer::StopTimer(int index)
+{
+	double n=0;
+	if(index >= (int)_timers.size())
+	{
+		Error("Cannot reset timer. Invalid handle.");
+		return HSA_FAILURE;
+	}
+#ifdef _WIN32
+       #ifndef _AMD
+	long long n1;
+	QueryPerformanceCounter((LARGE_INTEGER*)&(n1));
+	n = (double) n1;
+	#else
+	
+        // AMD Window Timing
+        
+	#endif
+	
+#else
+        // General Linux timing method
+        #ifndef _AMD
+	struct timeval s;
+	gettimeofday(&s, 0);
+	n = s.tv_sec * 1.0E3+ (double)(s.tv_usec/1.0E3);
+	#else
+       // AMD Linux timing
+
+	unsigned int unused;
+	n = __rdtscp(&unused);
+	#endif
+	
+#endif
+
+	n -= _timers[index]->_start;
+	_timers[index]->_start = 0;
+
+	#ifndef _AMD
+	_timers[index]->_clocks += n;
+	#else
+        //_timers[index]->_clocks += 10 * n /freq_in_100mhz;      // unit is ns
+	_timers[index]->_clocks += 1.0E-6 * 10  * n /freq_in_100mhz;  // convert to ms
+	cout << "_AMD is enabled!!!" << endl;
+	#endif
+	
+	return HSA_SUCCESS;
+}
+
+void PerfTimer::Error(string str)
+{
+    cout << str << endl;
+}
+
+
+double PerfTimer::ReadTimer(int index)
+{
+
+	if(index >= (int)_timers.size())
+	{
+		Error("Cannot read timer. Invalid handle.");
+		return HSA_FAILURE;
+	}
+	
+	double reading = double(_timers[index]->_clocks);
+	
+	reading = double(reading / _timers[index]->_freq);
+	
+	return reading;
+}
+
+
+uint64_t PerfTimer::CoarseTimestampUs() 
+{
+#ifdef _WIN32
+	uint64_t freqHz, ticks;
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freqHz);
+	QueryPerformanceCounter((LARGE_INTEGER *)&ticks);
+
+	// Scale numerator and divisor until (ticks * 1000000) fits in uint64_t.
+	while (ticks > (1ULL << 44)) {
+		ticks /= 16;
+		freqHz /= 16;
+	}
+
+	return (ticks * 1000000) / freqHz;
+#else
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &ts); 
+	return uint64_t(ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
+#endif
+}
+
+uint64_t PerfTimer::MeasureTSCFreqHz() 
+{
+	// Make a coarse interval measurement of TSC ticks for 1 gigacycles.
+	unsigned int unused;
+	uint64_t tscTicksEnd;
+
+	uint64_t coarseBeginUs = CoarseTimestampUs();
+	uint64_t tscTicksBegin = __rdtscp(&unused);
+	do 
+	{
+		tscTicksEnd = __rdtscp(&unused);
+	} 
+	while (tscTicksEnd - tscTicksBegin < 1000000000);
+	
+	uint64_t coarseEndUs = CoarseTimestampUs();
+
+	// Compute the TSC frequency and round to nearest 100MHz.
+	uint64_t coarseIntervalNs = (coarseEndUs - coarseBeginUs) * 1000;
+	uint64_t tscIntervalTicks = tscTicksEnd - tscTicksBegin;
+	return (tscIntervalTicks * 10 + (coarseIntervalNs / 2)) / coarseIntervalNs;
+}
+
+