--- /dev/null	2017-11-09 09:38:01.297999907 +0100
+++ new/src/hotspot/share/jfr/periodic/jfrModuleEvent.cpp	2018-04-09 14:49:34.507350696 +0200
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "classfile/classLoaderData.hpp"
+#include "classfile/moduleEntry.hpp"
+#include "classfile/packageEntry.hpp"
+#include "jfr/periodic/jfrModuleEvent.hpp"
+#include "jfr/utilities/jfrTraceTime.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "trace/tracing.hpp"
+
+// we want all requestable module events to have the same timestamp
+static JfrTraceTime requestableTime = 0;
+typedef void (*EventFunc)(const void* iterated_address, const JfrTraceTime& time, const ModuleEntry* module);
+class ModuleEventCallbackClosure : public ModuleClosure {
+ protected:
+  const JfrTraceTime& _time;
+  const EventFunc _event_func;
+  ModuleEventCallbackClosure(const JfrTraceTime& time, EventFunc ef) : _time(time), _event_func(ef) {}
+};
+
+class ModuleDependencyClosure : public ModuleEventCallbackClosure {
+ private:
+  const ModuleEntry* const _module;
+ public:
+   ModuleDependencyClosure(const ModuleEntry* module, const JfrTraceTime& time, EventFunc ef) :
+     ModuleEventCallbackClosure(time, ef), _module(module) {}
+   void do_module(ModuleEntry* const entry);
+};
+
+class ModuleExportClosure : public ModuleEventCallbackClosure {
+ private:
+  const PackageEntry* const _package;
+ public:
+  ModuleExportClosure(const PackageEntry* pkg, const JfrTraceTime& time, EventFunc ef) :
+    ModuleEventCallbackClosure(time, ef), _package(pkg) {}
+  void do_module(ModuleEntry* const entry);
+};
+
+static void write_module_dependency_event(const void* from_module, const JfrTraceTime& time, const ModuleEntry* to_module) {
+  EventModuleRequire event(UNTIMED);
+  event.set_endtime(time);
+  event.set_source((const ModuleEntry* const)from_module);
+  event.set_requiredModule(to_module);
+  event.commit();
+}
+
+static void write_module_export_event(const void* package, const JfrTraceTime& time, const ModuleEntry* qualified_export) {
+  EventModuleExport event(UNTIMED);
+  event.set_endtime(time);
+  event.set_exportedPackage((const PackageEntry*)package);
+  event.set_targetModule(qualified_export);
+  event.commit();
+}
+
+void ModuleDependencyClosure::do_module(ModuleEntry* to_module) {
+  assert_locked_or_safepoint(Module_lock);
+  assert(to_module != NULL, "invariant");
+  assert(_module != NULL, "invariant");
+  assert(_event_func != NULL, "invariant");
+  _event_func(_module, _time, to_module);
+}
+
+void ModuleExportClosure::do_module(ModuleEntry* qualified_export) {
+  assert_locked_or_safepoint(Module_lock);
+  assert(qualified_export != NULL, "invariant");
+  assert(_package != NULL, "invariant");
+  assert(_event_func != NULL, "invariant");
+  _event_func(_package, _time, qualified_export);
+}
+
+static void module_dependency_event_callback(ModuleEntry* module) {
+  assert_locked_or_safepoint(Module_lock);
+  assert(module != NULL, "invariant");
+  if (module->has_reads_list()) {
+    // create an individual event for each directed edge
+    ModuleDependencyClosure directed_edges(module, requestableTime, &write_module_dependency_event);
+    module->module_reads_do(&directed_edges);
+  }
+}
+
+static void module_export_event_callback(PackageEntry* package) {
+  assert_locked_or_safepoint(Module_lock);
+  assert(package != NULL, "invariant");
+  if (package->is_exported()) {
+    if (package->has_qual_exports_list()) {
+      // package is qualifiedly exported to a set of modules,
+      // create an event for each module in the qualified exported list
+      ModuleExportClosure qexports(package, requestableTime, &write_module_export_event);
+      package->package_exports_do(&qexports);
+      return;
+    }
+
+    assert(!package->is_qual_exported() || package->is_exported_allUnnamed(), "invariant");
+    // no qualified exports
+    // only create a single event with NULL
+    // for the qualified_exports module
+    write_module_export_event(package, requestableTime, NULL);
+  }
+}
+
+void JfrModuleEvent::generate_module_dependency_events() {
+  assert(0 == requestableTime, "invariant");
+  requestableTime = JfrTraceTime::now();
+  {
+    MutexLockerEx module_lock(Module_lock);
+    ClassLoaderDataGraph::modules_do(&module_dependency_event_callback);
+  }
+  requestableTime = 0;
+}
+
+void JfrModuleEvent::generate_module_export_events() {
+  assert(0 == requestableTime, "invariant");
+  requestableTime = JfrTraceTime::now();
+  {
+    MutexLockerEx module_lock(Module_lock);
+    ClassLoaderDataGraph::packages_do(&module_export_event_callback);
+  }
+  requestableTime = 0;
+}