Merge branch 'chrome_trace_event' into develop

Conflicts:
	src/apex/profiler.hpp

src/apex/CMakeLists.standalone

@@ -49,6 +49,7 @@ ${SENSOR_SOURCE}
 task_identifier.cpp
 ${tau_SOURCE}
 thread_instance.cpp
+trace_event_listener.cpp
 utils.cpp
 )
 

src/apex/apex.cpp

@@ -39,6 +39,7 @@
 
 #include "tau_listener.hpp"
 #include "profiler_listener.hpp"
+#include "trace_event_listener.hpp"
 #if defined(APEX_DEBUG) || defined(APEX_ERROR_HANDLING)
 // #define APEX_DEBUG_disabled
 #include "apex_error_handling.hpp"
@@ -249,7 +250,7 @@ void apex::_initialize()
         //write_lock_type l(listener_mutex);
         this->the_profiler_listener = new profiler_listener();
         // this is always the first listener!
-           listeners.push_back(the_profiler_listener);
+        listeners.push_back(the_profiler_listener);
         if (apex_options::use_tau() && tau_loaded)
         {
             listeners.push_back(new tau_listener());
@@ -260,6 +261,11 @@ void apex::_initialize()
             listeners.push_back(new otf2_listener());
         }
 #endif
+        if (apex_options::use_trace_event())
+        {
+            the_trace_event_listener = new trace_event_listener();
+            listeners.push_back(the_trace_event_listener);
+        }
 
 /* For the Jupyter support, always enable the concurrency handler. */
 #ifndef APEX_WITH_JUPYTER_SUPPORT

src/apex/apex.hpp

@@ -102,6 +102,8 @@ class apex
 #endif
 public:
     profiler_listener * the_profiler_listener;
+    event_listener * the_trace_event_listener;
+    event_listener * the_otf2_listener;
 #if APEX_HAVE_PROC
     proc_data_reader * pd_reader;
 #endif

src/apex/apex_types.h

@@ -252,6 +252,7 @@ inline unsigned int sc_nprocessors_onln()
     macro (APEX_OTF2, use_otf2, bool, false) \
     macro (APEX_OTF2_TESTING, otf2_testing, bool, false) \
     macro (APEX_OTF2_COLLECTIVE_SIZE, otf2_collective_size, int, 1) \
+    macro (APEX_TRACE_EVENT, use_trace_event, bool, false) \
     macro (APEX_POLICY, use_policy, bool, true) \
     macro (APEX_MEASURE_CONCURRENCY, use_concurrency, int, 0) \
     macro (APEX_MEASURE_CONCURRENCY_PERIOD, concurrency_period, int, 1000000) \

src/apex/profiler.hpp

@@ -15,6 +15,7 @@ class profiler;
 #include <math.h>
 #include "apex_options.hpp"
 #include "apex_types.h"
+#include "apex_assert.h"
 #include <chrono>
 #include <memory>
 #include "task_wrapper.hpp"
@@ -25,7 +26,7 @@ class profiler;
 #ifdef __INTEL_COMPILER
 #define CLOCK_TYPE high_resolution_clock
 #else
-#define CLOCK_TYPE steady_clock
+#define CLOCK_TYPE system_clock
 #endif
 
 namespace apex {
@@ -187,18 +188,31 @@ class profiler {
         this->is_resume = true;
         start = MYCLOCK::now();
     };
-    double elapsed(bool scaled = false) {
+    uint64_t get_start() {
+        APEX_ASSERT(!is_counter);
+        using namespace std::chrono;
+        uint64_t stamp = duration_cast<nanoseconds>(start.time_since_epoch()).count();
+        return stamp;
+    }
+    uint64_t get_stop() {
+        APEX_ASSERT(!is_counter);
+        using namespace std::chrono;
+        uint64_t stamp = duration_cast<nanoseconds>(end.time_since_epoch()).count();
+        return stamp;
+    }
+    static uint64_t get_time( void ) {
+        using namespace std::chrono;
+        uint64_t stamp = duration_cast<nanoseconds>(MYCLOCK::now().time_since_epoch()).count();
+        return stamp;
+    }
+    double elapsed(void) {
         if(is_counter) {
             return value;
         } else {
-            std::chrono::duration<double> time_span =
-            std::chrono::duration_cast<std::chrono::duration<double>>(end -
-            start);
-            if (scaled) {
-                return time_span.count()*get_cpu_mhz();
-            } else {
-                return time_span.count();
-            }
+            using namespace std::chrono;
+            duration<double> time_span =
+            duration_cast<duration<double>>(end - start);
+            return time_span.count();
         }
     }
     double exclusive_elapsed(void) {

src/apex/trace_event_listener.cpp

@@ -0,0 +1,193 @@
+//  Copyright (c) 2014 University of Oregon
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "trace_event_listener.hpp"
+#include "thread_instance.hpp"
+#include "apex.hpp"
+#include <iostream>
+#include <fstream>
+#include <memory>
+
+using namespace std;
+
+namespace apex {
+
+bool trace_event_listener::_initialized(false);
+
+trace_event_listener::trace_event_listener (void) : _terminate(false),
+    saved_node_id(apex::instance()->get_node_id()) {
+    std::stringstream ss;
+    ss << "trace_events." << saved_node_id << ".json";
+    trace.open(ss.str());
+    trace << fixed << "{\n";
+    trace << "\"displayTimeUnit\": \"ns\",\n";
+    trace << "\"traceEvents\": [\n";
+    trace << "{\"name\": \"program\", \"cat\": \"PERF\", \"ph\": \"B\", \"pid\": \"" <<
+        saved_node_id << "\", \"tid\": \"0\", \"ts\": \"" << profiler::get_time() << "\"},\n";
+    _initialized = true;
+}
+
+trace_event_listener::~trace_event_listener (void) {
+    trace << "{\"name\": \"program\", \"cat\": \"PERF\", \"ph\": \"E\", \"pid\": \"" <<
+        saved_node_id << "\", \"tid\": \"0\", \"ts\": \"" << profiler::get_time() << "\"}\n";
+    trace << "]\n}\n" << std::endl;
+    trace.close();
+    _initialized = true;
+}
+
+void trace_event_listener::on_startup(startup_event_data &data) {
+    APEX_UNUSED(data);
+    return;
+}
+
+void trace_event_listener::on_dump(dump_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+void trace_event_listener::on_shutdown(shutdown_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+        _terminate = true;
+    }
+    return;
+}
+
+void trace_event_listener::on_new_node(node_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+        // set node id
+    }
+    return;
+}
+
+void trace_event_listener::on_new_thread(new_thread_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+void trace_event_listener::on_exit_thread(event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+inline bool trace_event_listener::_common_start(std::shared_ptr<task_wrapper> &tt_ptr) {
+    if (!_terminate) {
+        _mutex.lock();
+        trace << "{\"name\": \"" << tt_ptr->task_id->get_name()
+              << "\", \"cat\": \"PERF\", \"ph\": \"B\", \"pid\": \""
+              << saved_node_id << "\", \"tid\": " << thread_instance::get_id()
+              << ", \"ts\": \"" << tt_ptr->prof->get_start() << "\"},\n";
+        _mutex.unlock();
+    } else {
+        return false;
+    }
+    return true;
+}
+
+bool trace_event_listener::on_start(std::shared_ptr<task_wrapper> &tt_ptr) {
+    return _common_start(tt_ptr);
+}
+
+bool trace_event_listener::on_resume(std::shared_ptr<task_wrapper> &tt_ptr) {
+    return _common_start(tt_ptr);
+}
+
+inline void trace_event_listener::_common_stop(std::shared_ptr<profiler> &p) {
+    if (!_terminate) {
+        _mutex.lock();
+        trace << "{\"name\": \"" << p->get_task_id()->get_name()
+              << "\", \"cat\": \"PERF\", \"ph\": \"E\", \"pid\": \"" << saved_node_id
+              << "\", \"tid\": " << thread_instance::get_id()
+              << ", \"ts\": \"" << p->get_stop() << "\"},\n";
+        _mutex.unlock();
+    }
+    return;
+}
+
+void trace_event_listener::on_stop(std::shared_ptr<profiler> &p) {
+    return _common_stop(p);
+}
+
+void trace_event_listener::on_yield(std::shared_ptr<profiler> &p) {
+    return _common_stop(p);
+}
+
+void trace_event_listener::on_sample_value(sample_value_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+void trace_event_listener::on_periodic(periodic_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+void trace_event_listener::on_custom_event(custom_event_data &data) {
+    APEX_UNUSED(data);
+    if (!_terminate) {
+    }
+    return;
+}
+
+void trace_event_listener::set_node_id(int node_id, int node_count) {
+    APEX_UNUSED(node_id);
+    APEX_UNUSED(node_count);
+}
+
+void trace_event_listener::set_metadata(const char * name, const char * value) {
+    APEX_UNUSED(name);
+    APEX_UNUSED(value);
+}
+
+std::string trace_event_listener::make_tid (uint32_t device, uint32_t context, uint32_t stream) {
+    cuda_thread_node tmp(device, context, stream);
+    size_t tid;
+    if (vthread_map.count(tmp) == 0) {
+        vthread_map.insert(std::pair<cuda_thread_node, size_t>(tmp,vthread_map.size()));
+    }
+    tid = vthread_map[tmp];
+    std::stringstream ss;
+    ss << "GPU: " << tid;
+    std::string label{ss.str()};
+    return label;
+}
+
+void trace_event_listener::on_async_event(uint32_t device, uint32_t context,
+    uint32_t stream, std::shared_ptr<profiler> &p) {
+    if (!_terminate) {
+        _mutex.lock();
+        trace << "{\"name\": \"" << p->get_task_id()->get_name()
+              << "\", \"cat\": \"PERF\", \"ph\": \"B\", \"pid\": \""
+              << saved_node_id << "\", \"tid\": " << make_tid(device, context, stream)
+              << ", \"ts\": \"" << p->get_start() << "\"},\n";
+        trace << "{\"name\": \"" << p->get_task_id()->get_name()
+              << "\", \"cat\": \"PERF\", \"ph\": \"E\", \"pid\": \"" << saved_node_id
+              << "\", \"tid\": " << make_tid(device, context, stream)
+              << ", \"ts\": \"" << p->get_stop() << "\"},\n";
+        _mutex.unlock();
+    }
+}
+
+/* This function is used by APEX threads so that TAU knows about them. */
+int initialize_worker_thread_for_trace_event(void) {
+    if (trace_event_listener::initialized())
+    {
+    }
+    return 0;
+}
+
+}// end namespace
+

src/apex/trace_event_listener.hpp

@@ -0,0 +1,89 @@
+//  Copyright (c) 2014 University of Oregon
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include "event_listener.hpp"
+#include <memory>
+#include <iostream>
+#include <fstream>
+#include <map>
+
+namespace apex {
+
+class trace_event_listener : public event_listener {
+
+    class cuda_thread_node {
+    public:
+        uint32_t _device;
+        uint32_t _context;
+        uint32_t _stream;
+        cuda_thread_node(uint32_t device, uint32_t context, uint32_t stream) :
+            _device(device), _context(context), _stream(stream) { }
+        bool operator==(const cuda_thread_node &rhs) const {
+            return (_device==rhs._device &&
+                    _context==rhs._context &&
+                    _stream==rhs._stream);
+        }
+        bool operator<(const cuda_thread_node &rhs) const {
+            if (_device<rhs._device) {
+                return true;
+            } else if (_device == rhs._device && _context<rhs._context) {
+                return true;
+            } else if (_device == rhs._device && _context==rhs._context && _stream<rhs._stream) {
+                return true;
+            }
+            return false;
+        }
+    };
+
+public:
+  	trace_event_listener (void);
+  	~trace_event_listener (void);
+  	static bool initialize_tau(int argc, char** avgv);
+  	inline static bool initialized(void) { return _initialized; }
+  	void on_startup(startup_event_data &data);
+  	void on_dump(dump_event_data &data);
+  	void on_reset(task_identifier * id)
+      	{ APEX_UNUSED(id); };
+  	void on_shutdown(shutdown_event_data &data);
+  	void on_new_node(node_event_data &data);
+  	void on_new_thread(new_thread_event_data &data);
+  	void on_exit_thread(event_data &data);
+  	bool on_start(std::shared_ptr<task_wrapper> &tt_ptr);
+  	void on_stop(std::shared_ptr<profiler> &p);
+  	void on_yield(std::shared_ptr<profiler> &p);
+  	bool on_resume(std::shared_ptr<task_wrapper> &tt_ptr);
+  	void on_task_complete(std::shared_ptr<task_wrapper> &tt_ptr) {
+    	APEX_UNUSED(tt_ptr);
+  	};
+  	void on_sample_value(sample_value_event_data &data);
+  	void on_periodic(periodic_event_data &data);
+  	void on_custom_event(custom_event_data &data);
+  	void on_send(message_event_data &data) { APEX_UNUSED(data); };
+  	void on_recv(message_event_data &data) { APEX_UNUSED(data); };
+  	void set_node_id(int node_id, int node_count);
+  	void set_metadata(const char * name, const char * value);
+    void on_async_event(uint32_t device, uint32_t context,
+        uint32_t stream, std::shared_ptr<profiler> &p);
+    std::string make_tid (uint32_t device, uint32_t context,
+        uint32_t stream);
+
+private:
+  	void _init(void);
+  	bool _terminate;
+  	bool _common_start(std::shared_ptr<task_wrapper> &tt_ptr);
+  	void _common_stop(std::shared_ptr<profiler> &p);
+  	static bool _initialized;
+  	std::ofstream trace;
+    std::mutex _mutex;
+    std::map<cuda_thread_node, size_t> vthread_map;
+    int saved_node_id;
+};
+
+int initialize_worker_thread_for_tau(void);
+
+}
+