| /* |
| * 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/jfrEvents.hpp" |
| #include "jfr/periodic/jfrModuleEvent.hpp" |
| #include "jfr/utilities/jfrTime.hpp" |
| #include "runtime/mutexLocker.hpp" |
| |
| // we want all periodic module events to have the same timestamp |
| static JfrTicks invocation_time; |
| |
| typedef void (*EventFunc)(const void* iterated_address, const ModuleEntry* module); |
| class ModuleEventCallbackClosure : public ModuleClosure { |
| protected: |
| const EventFunc _event_func; |
| ModuleEventCallbackClosure(EventFunc ef) : _event_func(ef) {} |
| }; |
| |
| class ModuleDependencyClosure : public ModuleEventCallbackClosure { |
| private: |
| const ModuleEntry* const _module; |
| public: |
| ModuleDependencyClosure(const ModuleEntry* module, EventFunc ef) : ModuleEventCallbackClosure(ef), _module(module) {} |
| void do_module(ModuleEntry* entry); |
| }; |
| |
| class ModuleExportClosure : public ModuleEventCallbackClosure { |
| private: |
| const PackageEntry* const _package; |
| public: |
| ModuleExportClosure(const PackageEntry* pkg, EventFunc ef) : ModuleEventCallbackClosure(ef), _package(pkg) {} |
| void do_module(ModuleEntry* entry); |
| }; |
| |
| static void write_module_dependency_event(const void* from_module, const ModuleEntry* to_module) { |
| EventModuleRequire event(UNTIMED); |
| event.set_endtime(invocation_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 ModuleEntry* qualified_export) { |
| EventModuleExport event(UNTIMED); |
| event.set_endtime(invocation_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, 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, 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, &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, &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, NULL); |
| } |
| } |
| |
| void JfrModuleEvent::generate_module_dependency_events() { |
| invocation_time = JfrTicks::now(); |
| MutexLockerEx module_lock(Module_lock); |
| ClassLoaderDataGraph::modules_do(&module_dependency_event_callback); |
| } |
| |
| void JfrModuleEvent::generate_module_export_events() { |
| invocation_time = JfrTicks::now(); |
| MutexLockerEx module_lock(Module_lock); |
| ClassLoaderDataGraph::packages_do(&module_export_event_callback); |
| } |