diff --git a/.gitignore b/.gitignore index 3df73a0..e4058d0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,10 @@ .cache build cmake-build-debug +stats/* +!stats/stats +!stats/stats.cfg + .vscode .idea diff --git a/CMakeLists.txt b/CMakeLists.txt index ea34a92..15d4e9d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.19) -project(motiv VERSION 1.0.0 LANGUAGES CXX) +project(motiv VERSION 2.2.0 LANGUAGES CXX) set(PROJECT_SOURCE_URL https://github.com/parcio/motiv) set(PROJECT_ISSUES_URL ${PROJECT_SOURCE_URL}/issues) @@ -27,8 +27,10 @@ set(PROJECT_SOURCES src/ReaderCallbacks.cpp src/main.cpp src/models/AppSettings.cpp + src/models/ColorMap.cpp src/models/Filetrace.cpp src/models/Filter.cpp + src/models/Search.cpp src/models/Slot.cpp src/models/SubTrace.cpp src/models/UITrace.cpp @@ -43,6 +45,7 @@ set(PROJECT_SOURCES src/models/communication/NonBlockingReceiveEvent.cpp src/models/communication/NonBlockingSendEvent.cpp src/models/communication/RequestCancelledEvent.cpp + src/models/mpianalysis/Node.cpp src/ui/ColorGenerator.cpp src/ui/ColorSynchronizer.cpp src/ui/widgets/InformationDock.cpp @@ -51,7 +54,9 @@ set(PROJECT_SOURCES src/ui/TraceDataProxy.cpp src/ui/views/CollectiveCommunicationIndicator.cpp src/ui/views/CommunicationIndicator.cpp + src/ui/views/FlamegraphView.cpp src/ui/views/GenericIndicator.cpp + src/ui/views/NodeIndicator.cpp src/ui/views/SlotIndicator.cpp src/ui/views/TimelineView.cpp src/ui/views/TraceOverviewTimelineView.cpp @@ -68,10 +73,15 @@ set(PROJECT_SOURCES src/ui/widgets/infostrategies/InformationDockElementBaseStrategy.cpp src/ui/widgets/infostrategies/InformationDockSlotStrategy.cpp src/ui/widgets/infostrategies/InformationDockTraceStrategy.cpp + src/ui/widgets/mpianalysis/LogicalClock.cpp src/ui/windows/FilterPopup.cpp + src/ui/windows/FlamegraphPopup.cpp src/ui/windows/MainWindow.cpp + src/ui/windows/MpiAnalysisWindow.cpp src/ui/windows/Otf2FileDialog.cpp src/ui/windows/RecentFilesDialog.cpp + src/ui/windows/SearchPopup.cpp + src/ui/windows/SettingsPopup.cpp src/utils.cpp ) @@ -109,3 +119,10 @@ install(TARGETS ${PROJECT_NAME} BUNDLE DESTINATION .) install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/motiv.desktop DESTINATION share/applications) install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/res/motiv.png DESTINATION share/icons) +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/res/buttons/book.png DESTINATION share/icons/buttons) + +file(GLOB BUTTON_PNG_FILES "${CMAKE_CURRENT_SOURCE_DIR}/res/buttons/*.png") +foreach(PNG_FILE ${BUTTON_PNG_FILES}) + install(FILES ${PNG_FILE} DESTINATION share/icons/buttons) +endforeach() + diff --git a/README.md b/README.md index 5c3c2ba..7fbc028 100644 --- a/README.md +++ b/README.md @@ -26,3 +26,5 @@ The code documentation is generated and available at [parcio.github.io/motiv](ht MOTIV is licensed under GPL v3 or later. The license is available [here](COPYING). [Jellyfish icon](https://www.flaticon.com/free-icons/jellyfish) created by [Freepik](https://www.flaticon.com/authors/freepik) from [Flaticon](https://www.flaticon.com/). + +[Buttons](https://commons.wikimedia.org/wiki/Tango_icons). \ No newline at end of file diff --git a/res/buttons/book.png b/res/buttons/book.png new file mode 100755 index 0000000..f8cfe17 Binary files /dev/null and b/res/buttons/book.png differ diff --git a/res/buttons/minus.png b/res/buttons/minus.png new file mode 100755 index 0000000..03f6432 Binary files /dev/null and b/res/buttons/minus.png differ diff --git a/res/buttons/plus.png b/res/buttons/plus.png new file mode 100755 index 0000000..b454527 Binary files /dev/null and b/res/buttons/plus.png differ diff --git a/res/buttons/plus_grey.png b/res/buttons/plus_grey.png new file mode 100755 index 0000000..fcd9993 Binary files /dev/null and b/res/buttons/plus_grey.png differ diff --git a/res/buttons/refresh.png b/res/buttons/refresh.png new file mode 100755 index 0000000..d8e1de6 Binary files /dev/null and b/res/buttons/refresh.png differ diff --git a/res/buttons/zoom_fit.png b/res/buttons/zoom_fit.png new file mode 100755 index 0000000..4b8c96d Binary files /dev/null and b/res/buttons/zoom_fit.png differ diff --git a/res/buttons/zoom_in.png b/res/buttons/zoom_in.png new file mode 100755 index 0000000..f82c48a Binary files /dev/null and b/res/buttons/zoom_in.png differ diff --git a/res/buttons/zoom_out.png b/res/buttons/zoom_out.png new file mode 100755 index 0000000..11994c6 Binary files /dev/null and b/res/buttons/zoom_out.png differ diff --git a/res/help.md b/res/help.md index 721d3ba..ec0e0b6 100644 --- a/res/help.md +++ b/res/help.md @@ -1,41 +1,58 @@ -# Views - -## Central view -In the center a visualisation of the otf2 trace is shown. - -**Each line** represents the function calls in an MPI rank. - -**Each block** represents a function call. Nested calls are shown on top. To see an entire call hover over it. The color of the block indicates its type. By default, these are: -- MPI calls: green -- OpenMP calls: red -- Any other calls: grey - -**Arrows** depict MPI communications between ranks. - -**Rectangles** stretching over all ranks show collective operations. - -## Overview -On the top an overview of the whole trace is shown. The current selected time window is highlighted. - - -# Usage - -## Navigating the view - -Use `CTRL` and scroll to **zoom in and out**. Use `SHIFT` and scroll to **move the view horizontally**. Reset the view with *View -> Reset* zoom or press `CTRL+R`. Alternatively, input the start and / or end time in the fields at the bottom of the view and press `ENTER` to zoom to a precise time window. - -In addition, click and drag a selection in the overview to select a time window. - -## Interactions - -Click on any element to see more information on it in the right pane. Click the *Zoom into view* button to zoom to the current selected item. - -## Filter - -Use *View -> Filter* or press `CTRL+S` to open a filter window. - -### Filter function call types - -Check or uncheck the kinds of functions that should be shown. - +### Basic controls +#### Notable shortcuts +- View related options: F1 (filter), F2 (settings), F3 (active thresholds) +- Zoom out: Space +- Zoom in: + - double click (onto indicators) + - CTRL+scroll +- Move left/right: Shift+scroll +- Search: CTRL+S +#### Notable interactions +- Making a selection: + - Click, hold the button and drag (overview) to the left or right to select the required section + - Input the start and / or end time in the fields at the bottom of the view and press ENTER +- Multi-threading view: +/- icons near ranknames +- Flamegraph view: right click (context menu) onto ranknames +- Toggle P2P (in and out): right click (context menu) onto ranknames +- Set custom colors: details pane (per default to the right) + +--- + +### Views +#### Central view (Selection) +Each **row** represents an **MPI rank**; when the thread view is expanded, multiple rows can represent a single MPI rank, with one thread per row. The mode of view is indicated by +/- icons: +- A + means the row can be expanded into the thread view. +- A - means the row has been expanded into the thread view. +- A grayed-out + indicates that no multi-threading was detected. + +Within and between the rows, there are **various indicators**: (1) rectangular, colored blocks, (2) arrows, and (3) blue frames. + +The rectangular blocks within the rows represent **function calls** or recordings of entered regions (often abbreviated as REG). Different functions are assigned different colors: +- MPI functions are usually yellowish-green. +- OpenMPI functions are usually red-orange. +- Other functions are assigned arbitrary colors. + +The arrows describe **point-to-point communications** (often abbreviated as P2P) between the ranks or threads, generally between rows. + +The blue, rectangular frames that span the rows describe **collective communications** (often abbreviated as CCM); ranks involved are highlighted by hatched function calls within these frames. + +#### Overview +Directly below the upper menu bar is the overview. Here, one can always see the entire trace and also the current selection for the main view. + +Differences from the main view include that only functions/regions are displayed here, and docking behavior: This element can be detached from and reattached to the main window. + +#### Flamegraph +Through a context menu regarding the rank names, one has the option to open the flamegraph view, for a particular rank. In this view, similar to the overview, only functions/regions are displayed; however, they are not overlapping but rather stacked according to their runtime into call hierarchies. + +This view is always synchronized with the central view or the current selection. + +--- + +### Colors +#### At start +Colors are assigned in static steps via RGB-coordinates, there are 159 valid positions between (0|0|0) and (255|255|255) which are assigned in the same order as the functions are encountered (first come, first serve). Encountered functions past these 159 positions will all be assigned white. +#### During Search +During a search, functions are assigned gray, except the one being searched for, which is displayed in purple. + +--- diff --git a/res/style.qss b/res/style.qss index ab2bc8f..6326d18 100644 --- a/res/style.qss +++ b/res/style.qss @@ -1,5 +1,52 @@ QToolTip { background-color: black; color: white; - border: black solid 1px + border: 1px outset #8A8A8A; + padding: 1px; + font-size: 11pt; } + +QScrollBar:vertical { + border: 1px solid #8A8A8A; + background: #6B6B6B; + width: 10px; + margin: 0px 0 0px 0; + border-radius: 5px; +} + +QScrollBar::handle:vertical { + background: qradialgradient(cx:0.5, cy:0.5, radius:1, fx:0.5, fy:0.5, stop:0 #B0C4DE, stop:1 #FFFFFF); + border: 1px solid #8A8A8A; + /*for some reason this border-radius is ignored, this causes the quadratic shape of the handle*/ + border-radius: 5px; + margin: 0px 0 0px 0; +} + +QScrollBar::handle:vertical:hover { + /* central point & focal point are inverted*/ + background: qradialgradient(cx:0.5, cy:0.5, radius:1, fx:0.5, fy:0.5, stop:0 #FFFFFF, stop:1 #B0C4DE); +} + +QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { + height: 0px; +} + + +QSlider::groove:vertical { + border: 1px solid #F5F5F5; + background: qradialgradient(cx:0.5, cy:0.5, radius:1, fx:0.5, fy:0.5, stop:0 #C0C0C0, stop:1 #FFFFFF); + width: 1px; + margin: 2px 0 2px 0; +} + +QSlider::handle:vertical { + background: qradialgradient(cx:0.5, cy:0.5, radius:1, fx:0.5, fy:0.5, stop:0 #B0C4DE, stop:1 #D3D3D3); + border: 1px solid gray; + height: 9px; + width: 9px; + margin: -2px -6px; + border-radius: 2px; +} + + + diff --git a/resources.qrc b/resources.qrc index 47e400b..8b5d2ed 100644 --- a/resources.qrc +++ b/resources.qrc @@ -4,5 +4,13 @@ res/help.md res/style.qss res/motiv.png + res/buttons/book.png + res/buttons/minus.png + res/buttons/plus.png + res/buttons/plus_grey.png + res/buttons/refresh.png + res/buttons/zoom_fit.png + res/buttons/zoom_in.png + res/buttons/zoom_out.png diff --git a/src/ReaderCallbacks.cpp b/src/ReaderCallbacks.cpp index eb7c135..331342e 100644 --- a/src/ReaderCallbacks.cpp +++ b/src/ReaderCallbacks.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -33,8 +33,7 @@ ReaderCallbacks::ReaderCallbacks(otf2::reader::reader &rdr) : collectiveCommunications_(std::vector()), slotsBuilding(), program_start_(), - rdr_(rdr) { - + rdr_(rdr) { } @@ -60,36 +59,44 @@ void ReaderCallbacks::event(const otf2::definition::location &, const otf2::even void ReaderCallbacks::event(const otf2::definition::location &loc, const otf2::event::enter &event) { - auto start = event.timestamp() - this->program_start_; - - Slot::Builder builder{}; - auto region = new otf2::definition::region(event.region()); - auto location = new otf2::definition::location(loc); - builder.start(start)->location(location)->region(region); - - std::vector *builders; - auto buildersIt = this->slotsBuilding.find(location->ref().get()); - if (buildersIt == this->slotsBuilding.end()) { - builders = new std::vector(); - this->slotsBuilding.insert({location->ref().get(), builders}); - } else { - builders = buildersIt->second; - } + if(mode_ == MPI_Analysis && event.region().paradigm() != otf2::common::paradigm_type::mpi){ + return; + }else{ + auto start = event.timestamp() - this->program_start_; + + Slot::Builder builder{}; + auto region = new otf2::definition::region(event.region()); + auto location = new otf2::definition::location(loc); + builder.start(start)->location(location)->region(region); + + std::vector *builders; + auto buildersIt = this->slotsBuilding.find(location->ref().get()); + if (buildersIt == this->slotsBuilding.end()) { + builders = new std::vector(); + this->slotsBuilding.insert({location->ref().get(), builders}); + } else { + builders = buildersIt->second; + } - builders->push_back(builder); + builders->push_back(builder); + } } void ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::leave &event) { - auto builders = this->slotsBuilding.at(location.ref().get()); + if(mode_ == MPI_Analysis && event.region().paradigm() != otf2::common::paradigm_type::mpi){ + return; + }else{ + auto builders = this->slotsBuilding.at(location.ref().get()); - Slot::Builder &builder = builders->back(); + Slot::Builder &builder = builders->back(); - auto end = event.timestamp() - this->program_start_; - builder.end(end); + auto end = event.timestamp() - this->program_start_; + builder.end(end); - this->slots_.push_back(new Slot(builder.build())); + this->slots_.push_back(new Slot(builder.build())); - builders->pop_back(); + builders->pop_back(); + } } @@ -100,10 +107,14 @@ void ReaderCallbacks::communicationEvent(T* self, uint32_t matching, ) { // Check for a pending matching call if (matchingPending.contains(matching)) { - auto& matchingEvents = matchingPending[matching]; + auto& matchingEvents = matchingPending[matching]; auto matchingEvent = matchingEvents->back(); - - auto communication = new Communication(matchingEvent, self); + Communication* communication = nullptr; + + // Check for the source of the start event in non-blocking communication + if(matchingEvent->getStartTime()<= self->getStartTime()) communication = new Communication(matchingEvent, self); + else communication = new Communication(self, matchingEvent); + communications_.push_back(communication); matchingEvents->pop_back(); @@ -138,7 +149,7 @@ void ReaderCallbacks::event(const otf2::definition::location &loc, const otf2::e auto comm = new types::communicator(receive.comm()); auto ev = new BlockingReceiveEvent(relative(receive.timestamp()), location, comm); - this->communicationEvent(ev, receive.sender(), pendingReceives, pendingSends); + this->communicationEvent(ev, receive.sender(), pendingReceives, pendingSends); } void ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_isend_request &request) { @@ -152,19 +163,18 @@ void ReaderCallbacks::event(const otf2::definition::location &location, const ot builder.start(start); builder.receiver(receiver); - this->uncompletedRequests.insert({request.request_id(), builder}); + // this->uncompletedIsendRequests.insert({request.request_id(), builder}); + this->uncompletedIsendRequests[location.ref()].insert({request.request_id(), builder}); } void -ReaderCallbacks::event(const otf2::definition::location &, const otf2::event::mpi_isend_complete &complete) { - if (!uncompletedRequests.contains(complete.request_id())) { +ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_isend_complete &complete) { + if (!uncompletedIsendRequests[location.ref()].contains(complete.request_id())) { throw std::logic_error("Found a mpi_isend_complete event with no matching mpi_isend_request event!"); } - auto builderVariant = uncompletedRequests[complete.request_id()]; - if(!holds_alternative(builderVariant)) { - throw std::logic_error("mpi_isend_complete event completes an mpi_ireceive event!"); - } + // auto loc = new otf2::definition::location(location); + auto builderVariant = uncompletedIsendRequests[location.ref()][complete.request_id()]; auto builder = get(builderVariant); @@ -173,44 +183,41 @@ ReaderCallbacks::event(const otf2::definition::location &, const otf2::event::mp auto ev = new NonBlockingSendEvent(builder.build()); - communicationEvent(ev, builder.receiver(), pendingSends, pendingReceives); + this->communicationEvent(ev, builder.receiver(), pendingSends, pendingReceives); } void -ReaderCallbacks::event(const otf2::definition::location &, const otf2::event::mpi_ireceive_complete &complete) { - if (!uncompletedRequests.contains(complete.request_id())) { +ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_ireceive_complete &complete) { + if (!uncompletedIrecvRequests[location.ref()].contains(complete.request_id())) { throw std::logic_error("Found a mpi_ireceive_complete event with no matching mpi_ireceive_request event!"); } - auto builderVariant = uncompletedRequests[complete.request_id()]; - if(!holds_alternative(builderVariant)) { - throw std::logic_error("mpi_ireceive_complete event completes an mpi_isend event!"); - } - + // auto builderVariant = uncompletedIrecvRequests[complete.request_id()]; + auto builderVariant = uncompletedIrecvRequests[location.ref()][complete.request_id()]; auto builder = get(builderVariant); + auto comm = new types::communicator (complete.comm()); + auto sender = complete.sender(); + builder.communicator(comm); + builder.sender(sender); + auto end = relative(complete.timestamp()); builder.end(end); - auto ev = new NonBlockingReceiveEvent(builder.build()); + auto ev = new NonBlockingReceiveEvent(builder.build()); - communicationEvent(ev, builder.sender(), pendingReceives, pendingSends); + this->communicationEvent(ev, builder.sender(), pendingReceives, pendingSends); } -void -ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_ireceive_request &request) { - +void +ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_ireceive_request &request) { NonBlockingReceiveEvent::Builder builder; - auto comm = new types::communicator (request.comm()); auto loc = new otf2::definition::location(location); - auto start = relative(request.timestamp()); - auto sender = request.sender(); - builder.communicator(comm); + auto start = relative(request.timestamp()); builder.location(loc); builder.start(start); - builder.sender(sender); - this->uncompletedRequests.insert({request.request_id(), builder}); + this->uncompletedIrecvRequests[location.ref()].insert({request.request_id(), builder}); } void ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_request_test &test) { @@ -235,10 +242,12 @@ ReaderCallbacks::event(const otf2::definition::location &location, const otf2::e } void ReaderCallbacks::event(const otf2::definition::location &location, const otf2::event::mpi_collective_end &anEnd) { + using CommGroup = otf2::definition::group; + if(ongoingCollectiveCommunication == nullptr) { ongoingCollectiveCommunication = new CollectiveCommunicationEvent::Builder(); std::vector members; - auto loc = new otf2::definition::location( location); + auto loc = new otf2::definition::location(location); auto comm = new types::communicator (anEnd.comm()); auto operation = anEnd.type(); auto root = anEnd.root(); @@ -256,13 +265,41 @@ void ReaderCallbacks::event(const otf2::definition::location &location, const ot ongoingCollectiveCommunication->members()->push_back(new CollectiveCommunicationEvent::Member(member.build())); ongoingCollectiveCommunicationMembers.erase(location.ref().get()); - // If the map is now empty, all ranks have completed the collective operation and the communication event can be build - if(ongoingCollectiveCommunicationMembers.empty()){ + // Check the number of members involved in this collective operation + size_t MembersSize = 0; + const auto& commVariant = anEnd.comm(); + auto interComm = std::get_if(&commVariant); + if (interComm != nullptr) { + auto groupA = std::get(interComm->groupA()); + auto groupB = std::get(interComm->groupB()); + MembersSize = groupA.size()+groupB.size(); + } else { + auto comm = std::get_if(&commVariant); + if (comm != nullptr) { + auto& group = std::get(comm->group()); + MembersSize = group.size(); + } + } + + // If the current number of members equals the actual size of the group, + // all ranks have completed the collective operation and the communication event can be build + auto currendMembersSize = ongoingCollectiveCommunication->members().get()->size(); + if(MembersSize == currendMembersSize){ auto event = new CollectiveCommunicationEvent(ongoingCollectiveCommunication->build()); collectiveCommunications_.push_back(event); delete ongoingCollectiveCommunication; ongoingCollectiveCommunication = nullptr; - } + } + + // Old version + // // If the map is now empty, all ranks have completed the collective operation and the communication event can be build + // if(ongoingCollectiveCommunicationMembers.empty()){ + // auto event = new CollectiveCommunicationEvent(ongoingCollectiveCommunication->build()); + // collectiveCommunications_.push_back(event); + // delete ongoingCollectiveCommunication; + // ongoingCollectiveCommunication = nullptr; + // } + } @@ -294,7 +331,8 @@ void ReaderCallbacks::events_done(const otf2::reader::reader &) { std::destroy(this->slotsBuilding.begin(), this->slotsBuilding.end()); std::destroy(this->pendingSends.begin(), this->pendingSends.end()); std::destroy(this->pendingReceives.begin(), this->pendingReceives.end()); - std::destroy(this->uncompletedRequests.begin(), this->uncompletedRequests.end()); + std::destroy(this->uncompletedIsendRequests.begin(), this->uncompletedIsendRequests.end()); + std::destroy(this->uncompletedIrecvRequests.begin(), this->uncompletedIrecvRequests.end()); } otf2::chrono::duration ReaderCallbacks::relative(otf2::chrono::time_point timepoint) const { diff --git a/src/ReaderCallbacks.hpp b/src/ReaderCallbacks.hpp index 4741a3d..04f3e9d 100644 --- a/src/ReaderCallbacks.hpp +++ b/src/ReaderCallbacks.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,12 +21,15 @@ #include #include +#include "src/models/AppSettings.hpp" #include "src/models/Slot.hpp" #include "src/models/communication/Communication.hpp" #include "src/models/communication/NonBlockingSendEvent.hpp" #include "src/models/communication/NonBlockingReceiveEvent.hpp" #include "src/models/communication/CollectiveCommunicationEvent.hpp" + + template using BuilderSetLocation = std::function; @@ -54,6 +57,8 @@ class ReaderCallbacks : public otf2::reader::callback { std::vector communications_; std::vector collectiveCommunications_; + Mode mode_ = AppSettings::getInstance().getMode(); + /** * Vectors for building the slot datatypes. Key is the location of the events. */ @@ -75,7 +80,11 @@ class ReaderCallbacks : public otf2::reader::callback { /** * Vectors for building the non blocking communication datatypes. Key is the request id. */ - std::map uncompletedRequests; + // std::map uncompletedIsendRequests; + std::map> uncompletedIsendRequests; + + // std::map uncompletedIrecvRequests; + std::map> uncompletedIrecvRequests; otf2::chrono::time_point program_start_; otf2::chrono::time_point program_end_; diff --git a/src/main.cpp b/src/main.cpp index 9b84b4c..dbfb971 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,6 +1,9 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, + * Björn Gehrke, + * Jessica Lafontaine, + * Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,6 +24,7 @@ #include #include "src/ui/windows/MainWindow.hpp" +#include "src/ui/windows/MpiAnalysisWindow.hpp" #include "src/ui/windows/RecentFilesDialog.hpp" // Decides wether performance information will be printed @@ -48,10 +52,13 @@ int main(int argc, char *argv[]) QCommandLineOption helpOption = parser.addHelpOption(); QCommandLineOption versionOption = parser.addVersionOption(); - QCommandLineOption testrunOption("t", QCoreApplication::translate("main", "#todo: fitting descr?"), "file"); + QCommandLineOption testrunOption("t", QCoreApplication::translate("main", "Runs motiv in test mode, i.e. pure trace-loading without GUI representation for benchmark purposes."), "file"); parser.addOption(testrunOption); parser.addPositionalArgument("file", QCoreApplication::translate("main", "filepath of the .otf2 trace file to open"), "[file]"); + QCommandLineOption modeOption("m", QCoreApplication::translate("main", "Selects the visualisation mode of Motiv.\n0: Default, 1: MPI Communication"), "mode"); + parser.addOption(modeOption); + parser.process(app); // Early return if help or version is shown @@ -65,20 +72,44 @@ int main(int argc, char *argv[]) filepath = positionalArguments.first(); } + bool modeValidity = true; + int mode = parser.value(modeOption).toInt(&modeValidity); + // Test run without window display if (parser.isSet(testrunOption)){ testRun = true; - auto dummyWindow = new MainWindow(parser.value(testrunOption)); + [[maybe_unused]] auto dummyMainWindow = new MpiAnalysisWindow(parser.value(testrunOption)); app.quit(); std::cout << "%application in general%" << appTimer.elapsed() << "%ms%"; return EXIT_SUCCESS; } RecentFilesDialog recentFilesDialog(&filepath); - if(!filepath.isEmpty() || recentFilesDialog.exec() == QDialog::Accepted) { - auto mainWindow = new MainWindow(filepath); - qInfo() << "motiv ready"; - mainWindow->show(); + + // Swap mode control to run Motiv in alternative mode by default + // Also, update mode ID in AppSettings.hpp + if((modeValidity || (!parser.isSet(modeOption))) && (!filepath.isEmpty() || recentFilesDialog.exec() == QDialog::Accepted)) { + if((!parser.isSet(modeOption)) || mode == 0){ + // if (parser.isSet(modeOption) && mode == 1){ + auto mainWindow = new MainWindow(filepath); + QString fullTitle; + QTextStream text(&fullTitle); + text << "Motiv " MOTIV_VERSION_STRING; + mainWindow->setWindowTitle(fullTitle); + qInfo() << "motiv ready"; + mainWindow->show(); + } + //if((!parser.isSet(modeOption)) || mode == 0){ + if (parser.isSet(modeOption) && mode == 1){ + auto mainWindow = new MpiAnalysisWindow(filepath); + QString fullTitle; + QTextStream text(&fullTitle); + text << "Motiv " MOTIV_VERSION_STRING; + mainWindow->setWindowTitle(fullTitle); + qInfo() << "motiv ready"; + mainWindow->show(); + + } } else { app.quit(); return EXIT_SUCCESS; diff --git a/src/models/AppSettings.cpp b/src/models/AppSettings.cpp index b5db60f..65ec9d3 100644 --- a/src/models/AppSettings.cpp +++ b/src/models/AppSettings.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -112,4 +112,12 @@ void AppSettings::toggleGlobalColorConfig(bool checked) bool AppSettings::getuseGlobalColorConfig(){ return this->useGlobalColorConfig; +} + +void AppSettings::setMode(Mode mode){ + this->mode = mode; +} + +Mode AppSettings::getMode(){ + return this->mode; } \ No newline at end of file diff --git a/src/models/AppSettings.hpp b/src/models/AppSettings.hpp index cfdeeda..a41300e 100644 --- a/src/models/AppSettings.hpp +++ b/src/models/AppSettings.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -22,6 +22,14 @@ #include #include +// Swap mode ID to run Motiv in alternative mode by default. +// Also, update mode control in main.cpp. +enum Mode{ + Default = 0, + MPI_Analysis = 1 +}; + + /** * @brief Singleton holding persistent information. * @@ -109,6 +117,10 @@ Q_OBJECT void clearColorConfig(); bool getuseGlobalColorConfig(); + + void setMode(Mode mode); + + Mode getMode(); public: Q_SIGNALS: /** @@ -132,6 +144,7 @@ public Q_SLOTS: QStringList recentlyOpenedFiles_; QString colorConfigName_; bool useGlobalColorConfig = false; + Mode mode = Default; }; diff --git a/src/models/ColorMap.cpp b/src/models/ColorMap.cpp index 5753d5a..d2d0de0 100644 --- a/src/models/ColorMap.cpp +++ b/src/models/ColorMap.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/models/ColorMap.hpp b/src/models/ColorMap.hpp index fc1c6c6..a474fd4 100644 --- a/src/models/ColorMap.hpp +++ b/src/models/ColorMap.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/models/Filter.cpp b/src/models/Filter.cpp index c379d76..528b9a3 100644 --- a/src/models/Filter.cpp +++ b/src/models/Filter.cpp @@ -24,3 +24,12 @@ SlotKind Filter::getSlotKinds() const { void Filter::setSlotKinds(SlotKind slotKinds) { slotKinds_ = slotKinds; } + + +CommunicationKind Filter::getCommunicationKinds() const{ + return communicationKinds_; +} + +void Filter::setCommunicationKind(CommunicationKind communicationKind){ + communicationKinds_ = communicationKind; +} \ No newline at end of file diff --git a/src/models/Filter.hpp b/src/models/Filter.hpp index 68af3f1..340ef63 100644 --- a/src/models/Filter.hpp +++ b/src/models/Filter.hpp @@ -18,9 +18,11 @@ #ifndef MOTIV_FILTER_HPP #define MOTIV_FILTER_HPP -#define FILTER_DEFAULT ((SlotKind) (SlotKind::MPI | SlotKind::OpenMP | SlotKind::Plain)) +#define SLOT_FILTER_DEFAULT ((SlotKind) (SlotKind::MPI | SlotKind::OpenMP | SlotKind::Plain)) +#define COMMUNICATION_FILTER_DEFAULT ((CommunicationKind) (CommunicationKind::PointToPoint | CommunicationKind::Collective | CommunicationKind::Synchronizing)) #include "Slot.hpp" +#include "src/models/communication/CommunicationKind.hpp" /** * @brief Class containing options to filter the view. @@ -43,8 +45,24 @@ class Filter { */ void setSlotKinds(SlotKind slotKinds); + /** + * @brief Returns the kinds of communication that should be rendered. + * @return The kinds of communication that should be rendered. + */ + [[nodiscard]] CommunicationKind getCommunicationKinds() const; + + /** + * @brief Sets the communication that should be rendered. + * + * Note that CommunicationKind values can be used as a flag and be combined with a bitwise or. + * @param communicationKinds The kind of communication that should be rendered. + */ + void setCommunicationKind(CommunicationKind communicationKinds); + + private: // fields - SlotKind slotKinds_ = FILTER_DEFAULT; + SlotKind slotKinds_ = SLOT_FILTER_DEFAULT; + CommunicationKind communicationKinds_ = COMMUNICATION_FILTER_DEFAULT; }; diff --git a/src/models/Range.hpp b/src/models/Range.hpp index d4510c6..5444c7f 100644 --- a/src/models/Range.hpp +++ b/src/models/Range.hpp @@ -61,14 +61,17 @@ class Range { Range(const Range &rhs) { if (rhs.vec_) { vec_ = new std::vector(*rhs.vec_); - begin_ = std::find(vec_->begin(), vec_->end(), *rhs.begin_); - end_ = std::find(vec_->begin(), vec_->end(), *rhs.end_); + auto dist_begin = std::distance(rhs.vec_->begin(), rhs.begin_); + auto dist_end = std::distance(rhs.vec_->begin(), rhs.end_); + begin_ = vec_->begin() + dist_begin; + end_ = vec_->begin() + dist_end; } else { begin_ = rhs.begin_; end_ = rhs.end_; } }; + /** * Construct a range from a vector. * @@ -95,9 +98,14 @@ class Range { if (rhs.vec_) { delete vec_; - vec_ = new std::vector(*rhs.vec_); - begin_ = std::find(vec_->begin(), vec_->end(), *rhs.begin_); - end_ = std::find(vec_->begin(), vec_->end(), *rhs.end_); + vec_ = new std::vector(*rhs.vec_); + // begin_ = std::find(vec_->begin(), vec_->end(), *rhs.begin_); + // end_ = std::find(vec_->begin(), vec_->end(), *rhs.end_); + + auto dist_begin = std::distance(rhs.vec_->begin(), rhs.begin_); + auto dist_end = std::distance(rhs.vec_->begin(), rhs.end_); + begin_ = vec_->begin() + dist_begin; + end_ = vec_->begin() + dist_end; } else { begin_ = rhs.begin_; end_ = rhs.end_; @@ -130,6 +138,14 @@ class Range { delete vec_; }; + + int getIndexOf(const T &item) const { + auto it = std::find(vec_->begin(), vec_->end(), item); + if (it != vec_->end()) { + return std::distance(vec_->begin(), it); + }else return -1; + } + private: std::vector *vec_ = nullptr; It begin_; diff --git a/src/models/Search.cpp b/src/models/Search.cpp new file mode 100644 index 0000000..a07539c --- /dev/null +++ b/src/models/Search.cpp @@ -0,0 +1,61 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include + +#include "src/models/Search.hpp" + +Search::Search(TraceDataProxy *data, QListWidget *itemList, QWidget *parent): data(data), itemList(itemList), QListWidget(parent){ + if(this->data == nullptr) throw std::invalid_argument("data (TraceDataProxy) is null"); + + for(const auto &item : data->getFullTrace()->getSlots()){ + for(const auto &slot: item.second){ + QString name = QString::fromStdString(slot->region->name().str()); + QList matches = this->itemList->findItems(name, Qt::MatchExactly); + if(matches.isEmpty()) this->itemList->addItem(name); + } + } + + this->itemList->sortItems(Qt::AscendingOrder); +} + +void Search::findName(QString subname, QListWidget *itemList) { + for (int i = 0; i < itemList->count(); i++) { + QListWidgetItem *item = itemList->item(i); + QString name = item->text(); + if (!name.contains(subname,Qt::CaseInsensitive)){ + item->setHidden(true); + } else item->setHidden(false); + } +} + + +std::list Search::createItemList(QString searchedName){ + std::list resultList; + for(const auto &item : data->getFullTrace()->getSlots()){ + for(const auto &slot: item.second){ + QString name = QString::fromStdString(slot->region->name().str()); + if(name == searchedName){ + resultList.push_back(slot); + } + } + } + return resultList; +} + diff --git a/src/models/Search.hpp b/src/models/Search.hpp new file mode 100644 index 0000000..10008cd --- /dev/null +++ b/src/models/Search.hpp @@ -0,0 +1,55 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_Search_HPP +#define MOTIV_Search_HPP + +#include + +#include "src/ui/TraceDataProxy.hpp" + +/** + * @brief A class for handling search functionality + * @note It holds a distinct list of all slot function names. + */ +class Search : QListWidget { +Q_OBJECT +public: + Search(TraceDataProxy *data, QListWidget *itemList, QWidget *parent=nullptr); + + /** + * @brief Shortens the item list based on the provided string (hides all other items). + * @param string The string to match + * @param itemList Pointer to the QListWidget for modification + */ + void findName(QString string, QListWidget *itemList); + + /** + * @brief Creates an iteratable item list for "Next" and "Previous" actions (doubly linked). + * @param name The name to search for + * @return List of TimedElement pointers for iteration + */ + std::list createItemList(QString name); + + +private: + QListWidget *itemList = nullptr; + TraceDataProxy* data = nullptr; + +}; +#endif //MOTIV_Search_HPP \ No newline at end of file diff --git a/src/models/Slot.cpp b/src/models/Slot.cpp index d692b5a..80de547 100644 --- a/src/models/Slot.cpp +++ b/src/models/Slot.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/models/ViewSettings.cpp b/src/models/ViewSettings.cpp index 575e0cf..1309e7c 100644 --- a/src/models/ViewSettings.cpp +++ b/src/models/ViewSettings.cpp @@ -1,6 +1,9 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, + * Björn Gehrke, + * Jessica Lafontaine, + * Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,6 +20,20 @@ */ #include "ViewSettings.hpp" + +//#todo: delete later +//#include + +ViewSettings* ViewSettings::instance = nullptr_t(); + +ViewSettings::ViewSettings(){} + +ViewSettings* ViewSettings::getInstance() +{ + if (instance == nullptr) instance = new ViewSettings(); + return instance; +} + int ViewSettings::getZoomQuotient() const { return zoomFactor_; } @@ -32,3 +49,168 @@ Filter ViewSettings::getFilter() const { void ViewSettings::setFilter(Filter filter) { filter_ = filter; } + +int ViewSettings::getRowHeight() { + return this->rowHeight; +} + +void ViewSettings::setRowHeight(int height) { + if(height>=15) this->rowHeight = height; +} + +void ViewSettings::setSearchName(QString searchName) { + this->searchName = searchName; +} + +QString ViewSettings::getSearchName() { + return this->searchName; +} + +std::map< OTF2_StringRef, std::pair>>>>* ViewSettings::getRankThreadMap() { + return &rankThreadMap; +} + +std::map< OTF2_StringRef, otf2::definition::location_group *>* ViewSettings::getRankAdrMap() { + return &rankAdrMap; +} + +QIcon* ViewSettings::getIcon(std::string key) { + return &Icons_.at(key); +} + +int ViewSettings::getFlamegraphRankRef() { + return this->rankRef; +} + +void ViewSettings::setFlamegraphRankRef(int newRankRef) { + this->rankRef = newRankRef; +} + + +void ViewSettings::setCountIndicatorsREG(bool newState) { + this->countIndicatorsREG = newState; +} + +void ViewSettings::setCountIndicatorsP2P(bool newState) { + this->countIndicatorsP2P = newState; +} + +void ViewSettings::setCountIndicatorsCCM(bool newState) { + this->countIndicatorsCCM = newState; +} + +void ViewSettings::setCountIndicatorDetailsFlamegraph(bool newState) { + this->countIndicatorDetailsFlamegraph = newState; +} + +void ViewSettings::setPxThresholdFlamegraph(bool newState) { + this->pxThresholdFlamegraph = newState; +} + +void ViewSettings::setUseRealWidthFlamegraph(bool newState) { + this->useRealWidthFlamegraph = newState; +} + +void ViewSettings::setUseRealWidthMainWindow(bool newState) { + this->useRealWidthMainWindow = newState; +} + +void ViewSettings::setUseBorderOverview(bool newState) { + this->useBorderOverview = newState; +} + +void ViewSettings::setUsePriorityOverview(bool newState) { + this->usePriorityOverview = newState; +} + +void ViewSettings::setColorCodingTimeRecords(bool newState) { + this->colorCodingTimeRecords = newState; +} + +void ViewSettings::setAbsoluteDurationsForSliders(bool newState) { + this->absoluteDurationsForSliders = newState; +} + +void ViewSettings::setUseREGSliderForOV(bool newState) { + this->useREGSliderForOV = newState; +} + +void ViewSettings::setActiveThresholdOV(double newVal) { + this->activeThresholdOV = newVal; +} + +void ViewSettings::setActiveThresholdREG(double newVal) { + this->activeThresholdREG = newVal; +} + +void ViewSettings::setActiveThresholdP2P(double newVal) { + this->activeThresholdP2P = newVal; +} + +void ViewSettings::setActiveThresholdCCM(double newVal) { + this->activeThresholdCCM = newVal; +} + +bool ViewSettings::getCountIndicatorsREG() { + return this->countIndicatorsREG; +} + +bool ViewSettings::getCountIndicatorsP2P() { + return this->countIndicatorsP2P; +} + +bool ViewSettings::getCountIndicatorsCCM() { + return this->countIndicatorsCCM; +} + +bool ViewSettings::getCountIndicatorDetailsFlamegraph() { + return this->countIndicatorDetailsFlamegraph; +} + +bool ViewSettings::getPxThresholdFlamegraph() { + return this->pxThresholdFlamegraph; +} + +bool ViewSettings::getUseRealWidthFlamegraph() { + return this->useRealWidthFlamegraph; +} + +bool ViewSettings::getUseRealWidthMainWindow() { + return this->useRealWidthMainWindow; +} + +bool ViewSettings::getUseBorderOverview() { + return this->useBorderOverview; +} + +bool ViewSettings::getUsePriorityOverview() { + return this->usePriorityOverview; +} + +bool ViewSettings::getColorCodingTimeRecords() { + return this->colorCodingTimeRecords; +} + +bool ViewSettings::getAbsoluteDurationsForSliders() { + return this->absoluteDurationsForSliders; +} + +bool ViewSettings::getUseREGSliderForOV() { + return this->useREGSliderForOV; +} + +double ViewSettings::getActiveThresholdOV() { + return this->activeThresholdOV; +} + +double ViewSettings::getActiveThresholdREG() { + return this->activeThresholdREG; +} + +double ViewSettings::getActiveThresholdP2P() { + return this->activeThresholdP2P; +} + +double ViewSettings::getActiveThresholdCCM() { + return this->activeThresholdCCM; +} \ No newline at end of file diff --git a/src/models/ViewSettings.hpp b/src/models/ViewSettings.hpp index 1b54ceb..139d161 100644 --- a/src/models/ViewSettings.hpp +++ b/src/models/ViewSettings.hpp @@ -1,6 +1,9 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, + * Björn Gehrke, + * Jessica Lafontaine, + * Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,7 +24,12 @@ #include "src/models/Slot.hpp" #include "Filter.hpp" +#include +#include +#include + #define SETTINGS_DEFAULT_ZOOM_QUOTIENT 25 +#define SETTINGS_DEFAULT_ROW_HEIGHT 30 /** * @brief The ViewSettings class encapsulates settings for the main view. @@ -31,6 +39,7 @@ */ class ViewSettings { public: + static ViewSettings* getInstance(); /** * @brief Returns the current filter. @@ -63,7 +72,67 @@ class ViewSettings { */ void setZoomFactor(int zoomFactor); + int getRowHeight(); + + void setRowHeight(int height); + + void setSearchName(QString name); + + QString getSearchName(); + + std::map< OTF2_StringRef, std::pair>>>>* getRankThreadMap(); + + std::map< OTF2_StringRef, otf2::definition::location_group*>* getRankAdrMap(); + + QIcon* getIcon(std::string key); + + int getFlamegraphRankRef(); + + void setFlamegraphRankRef(int rankRef); + + void setCountIndicatorsREG(bool newState); + void setCountIndicatorsP2P(bool newState); + void setCountIndicatorsCCM(bool newState); + void setCountIndicatorDetailsFlamegraph(bool newState); + void setPxThresholdFlamegraph(bool newState); + void setUseRealWidthFlamegraph(bool newState); + void setUseRealWidthMainWindow(bool newState); + void setUseBorderOverview(bool newState); + void setUsePriorityOverview(bool newState); + void setColorCodingTimeRecords(bool newState); + void setAbsoluteDurationsForSliders(bool newState); + void setUseREGSliderForOV(bool newState); + + void setActiveThresholdOV(double newVal); + void setActiveThresholdREG(double newVal); + void setActiveThresholdP2P(double newVal); + void setActiveThresholdCCM(double newVal); + + bool getCountIndicatorsREG(); + bool getCountIndicatorsP2P(); + bool getCountIndicatorsCCM(); + bool getCountIndicatorDetailsFlamegraph(); + bool getPxThresholdFlamegraph(); + bool getUseRealWidthFlamegraph(); + bool getUseRealWidthMainWindow(); + bool getUseBorderOverview(); + bool getUsePriorityOverview(); + bool getColorCodingTimeRecords(); + bool getAbsoluteDurationsForSliders(); + bool getUseREGSliderForOV(); + + double getActiveThresholdOV(); + double getActiveThresholdREG(); + double getActiveThresholdP2P(); + double getActiveThresholdCCM(); + + QString globalMessage; + private: + static ViewSettings* instance; + ViewSettings(); + ViewSettings(const ViewSettings& obj) = delete; + /** * Backing field for the current zoom factor. */ @@ -72,6 +141,50 @@ class ViewSettings { * Backing field for the current filter. * */ Filter filter_; + + int rowHeight = SETTINGS_DEFAULT_ROW_HEIGHT; + + std::map< OTF2_StringRef, std::pair>>>> rankThreadMap{}; + + std::map< OTF2_StringRef, otf2::definition::location_group *> rankAdrMap{}; + + QString searchName = ""; + + QString executablePath = QCoreApplication::applicationDirPath(); + + std::map Icons_ { + {std::pair{"plus", ":/res/buttons/plus.png"}}, + {std::pair{"plus_grey", ":/res/buttons/plus_grey.png"}}, + {std::pair{"minus", ":/res/buttons/minus.png"}}, + {std::pair{"zoom_in", ":/res/buttons/zoom_in.png"}}, + {std::pair{"zoom_out", ":/res/buttons/zoom_out.png"}}, + {std::pair{"zoom_fit", ":/res/buttons/zoom_fit.png"}}, + {std::pair{"search", ":/res/buttons/search.png"}}, + {std::pair{"book", ":/res/buttons/book.png"}}, + {std::pair{"refresh", ":/res/buttons/refresh.png"}}, + {std::pair{"maximize", ":/res/buttons/maximize.png"}} + }; + + int rankRef; + + bool countIndicatorsREG=false; + bool countIndicatorsP2P=false; + bool countIndicatorsCCM=false; + bool countIndicatorDetailsFlamegraph=true; + bool pxThresholdFlamegraph=true; + bool useRealWidthFlamegraph=true; + bool useRealWidthMainWindow=false; + + bool useBorderOverview=true; + bool usePriorityOverview=true; + bool colorCodingTimeRecords=true; + bool absoluteDurationsForSliders=true; + bool useREGSliderForOV=false; + + double activeThresholdOV=0; + double activeThresholdREG=0; + double activeThresholdP2P=0; + double activeThresholdCCM=0; }; diff --git a/src/models/communication/CollectiveCommunicationEvent.cpp b/src/models/communication/CollectiveCommunicationEvent.cpp index d6cd685..6e74a9a 100644 --- a/src/models/communication/CollectiveCommunicationEvent.cpp +++ b/src/models/communication/CollectiveCommunicationEvent.cpp @@ -49,7 +49,18 @@ types::communicator * CollectiveCommunicationEvent::getCommunicator() const { } CommunicationKind CollectiveCommunicationEvent::getKind() const { - return Collective; + switch(operation){ + case otf2::collective_type::barrier: + case otf2::collective_type::all_gather: + case otf2::collective_type::all_gatherv: + case otf2::collective_type::all_to_all: + case otf2::collective_type::all_to_allv: + case otf2::collective_type::all_to_allw: + case otf2::collective_type::all_reduce: + return Synchronizing; + default: + return Collective; + } } otf2::collective_type CollectiveCommunicationEvent::getOperation() const { diff --git a/src/models/communication/CommunicationKind.hpp b/src/models/communication/CommunicationKind.hpp index 64fe886..df45062 100644 --- a/src/models/communication/CommunicationKind.hpp +++ b/src/models/communication/CommunicationKind.hpp @@ -29,31 +29,45 @@ enum CommunicationKind { /** * The communication event was a blocking send operation (e.g. MPI_SSEND) */ - BlockingSend, + BlockingSend = 1 << 0, /** * The communication event was a blocking receive operation (e.g. MPI_SRECEIVE) */ - BlockingReceive, + BlockingReceive = 1 << 1, /** * The communication event was a non blocking send operation (e.g. MPI_ISEND) */ - NonBlockingSend, + NonBlockingSend = 1 << 2, /** * The communication event was a non blocking receive operation (e.g. MPI_IRECEIVE) */ - NonBlockingReceive, + NonBlockingReceive = 1 << 3, + + /** + * The communication event was a synchronizing and collective operation (e.g. MPI_BARRIER) + */ + Synchronizing = 1 << 4, /** * The communication event was a collective operation (e.g. MPI_REDUCE) */ - Collective, + Collective = (1 << 5 | Synchronizing), /** * The communication event was a cancellation event (e.g. MPI_REQUEST_CANCEL) */ - RequestCancelled + RequestCancelled = 1 << 6, + + /** + * The communication event was a Point to Point operation + */ + PointToPoint = (BlockingSend | BlockingReceive | NonBlockingReceive | NonBlockingSend), + + BlockingPointToPoint = (BlockingSend | BlockingReceive), + + NonBlockingPointToPoint = (NonBlockingReceive | NonBlockingSend) }; #endif //MOTIV_COMMUNICATIONKIND_HPP diff --git a/src/models/mpianalysis/Node.cpp b/src/models/mpianalysis/Node.cpp new file mode 100644 index 0000000..2a6cb9a --- /dev/null +++ b/src/models/mpianalysis/Node.cpp @@ -0,0 +1,137 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include + + +#include "Node.hpp" + +Node::Node(Slot* slot): slot(slot){ +} + +bool Node::hasCommunication(){ + if(communication == nullptr) return false; + else return true; +} + +bool Node::hasCollectiveCommunication(){ + if(collectiveCommunication == nullptr) return false; + else return true; +} + +void Node::setCommunication(const Communication *comm){ + this->communication = comm; +} + +void Node::setCollectiveCommunication(const CollectiveCommunicationEvent *collectiveCommunication){ + this->collectiveCommunication = collectiveCommunication; +} + +void Node::addConnectedNode(Node* node){ + // this->connectedNodes[node->getLocation()] = node; + this->connectedNodes[node->getLocation()].push_back(node); +} + +void Node::addConnectedNode(uint16_t location, std::vector nodes){ + this->connectedNodes[location] = nodes; +} + + void Node::addConnectedNode(std::vector nodes){ + for(auto node : nodes){ + if(node!=this) this->connectedNodes[node->getLocation()].push_back(node); + } + + } + +Slot* Node::getSlot(){ + return slot; +} + +uint64_t Node::getLocation(){ + return this->slot->location->ref(); +} + +otf2::definition::string Node::getRegionName(){ + return slot->region->name(); +} + +const Communication* Node::getCommunication(){ + if(this->hasCommunication()) return this->communication; + else throw std::runtime_error("No communication present"); +} + +const CollectiveCommunicationEvent* Node::getCollectiveCommunication(){ + if(this->hasCollectiveCommunication()) return this->collectiveCommunication; + else{ + throw std::runtime_error("No collective communication present"); + } +} + +CommunicationKind Node::getCommunicationKind(){ + if(this->hasCommunication()) return this->getOwnEvent()->getKind(); + else if(this->hasCollectiveCommunication()) return this->collectiveCommunication->getKind(); + else throw std::runtime_error("No communication present"); +} + +std::map>& Node::getConnectedNodes(){ + if(!connectedNodes.empty()) return connectedNodes; + else throw std::runtime_error("connectedNodes vector is empty"); +} + +uint64_t Node::getConnectedCommunicationRank(){ + if(!this->hasCommunication()) throw std::runtime_error("No p2p communication present"); + else if(communication->getStartEvent()->getLocation()->ref() != this->getLocation()) return communication->getStartEvent()->getLocation()->ref(); + else return communication->getEndEvent()->getLocation()->ref(); +} + +const CommunicationEvent* Node::getOwnEvent(){ + if(!this->hasCommunication()) throw std::runtime_error("No p2p communication present"); + else if(communication->getStartEvent()->getLocation()->ref() == this->getLocation()) return communication->getStartEvent(); + else return communication->getEndEvent(); +} + +const CommunicationEvent* Node::getConnectedEvent(){ + if(!this->hasCommunication()) throw std::runtime_error("No p2p communication present"); + else if(communication->getStartEvent()->getLocation()->ref() != this->getLocation()) return communication->getStartEvent(); + else return communication->getEndEvent(); +} + +// void Node::setColor(){ +// std::string str = this->slot->region->name().str(); +// if(communication != nullptr || collectiveCommunication != nullptr) { +// if((this->getCommunicationKind() & CommunicationKind::BlockingPointToPoint) || +// (this->getCommunicationKind() == CommunicationKind::Synchronizing)) this->color = Qt::red; +// else this->color = Qt::blue; +// }else { +// QString regionName = QString::fromStdString(this->slot->region->name().str()); +// QString pattern = "(.*)(wait|probe|test)(.*)"; +// QRegularExpression regex(pattern, QRegularExpression::CaseInsensitiveOption); + +// if(regex.match(regionName).hasMatch()) this->color = Qt::darkGray; +// else this->color = Qt::blue; +// } +// } + +// QColor Node::getColor(){ +// return this->color; +// } + +bool Node::operator<(const Node& other) const { + return slot->endTime < other.slot->endTime; +} \ No newline at end of file diff --git a/src/models/mpianalysis/Node.hpp b/src/models/mpianalysis/Node.hpp new file mode 100644 index 0000000..8d1431f --- /dev/null +++ b/src/models/mpianalysis/Node.hpp @@ -0,0 +1,82 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_NODE_HPP +#define MOTIV_NODE_HPP + +#include + +#include "src/models/communication/CollectiveCommunicationEvent.hpp" +#include "src/models/communication/Communication.hpp" +#include "src/models/Slot.hpp" + +class Node { +public: + Node(Slot* slot); + +public: //methods + +// Slot related functions +Slot* getSlot(); +uint64_t getLocation(); +otf2::definition::string getRegionName(); + + +// Communication related functions +bool hasCommunication(); +bool hasCollectiveCommunication(); + +void setCommunication(const Communication *communication); +void setCollectiveCommunication(const CollectiveCommunicationEvent *collectiveCommunication); + +const Communication* getCommunication(); +const CollectiveCommunicationEvent* getCollectiveCommunication(); +CommunicationKind getCommunicationKind(); + +// only for Nodes with P2P communication +uint64_t getConnectedCommunicationRank(); +const CommunicationEvent* getOwnEvent(); +const CommunicationEvent* getConnectedEvent(); + + +// Node related functions +void addConnectedNode(Node* node); +void addConnectedNode(uint16_t location, std::vector nodes); +void addConnectedNode(std::vector nodes); + +// void setColor(); +// QColor getColor(); + +std::map>& getConnectedNodes(); + +// Custom comparison operator to sort Node objects in ascending order of endTime +bool operator<(const Node& other) const; + +private: //data + Slot *slot; + // QColor color; + + std::map> connectedNodes; + + const Communication *communication = nullptr; + + // Exists only for collective communication Nodes + const CollectiveCommunicationEvent *collectiveCommunication = nullptr; +}; + +#endif //MOTIV_NODE_HPP \ No newline at end of file diff --git a/src/ui/ColorGenerator.cpp b/src/ui/ColorGenerator.cpp index 6850d1e..ef720e9 100644 --- a/src/ui/ColorGenerator.cpp +++ b/src/ui/ColorGenerator.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -19,7 +19,7 @@ #include "src/ui/Constants.hpp" // Increment value for color updates, controls color diversity -constexpr int COLOR_INCREMENT = 50; +constexpr int COLOR_INCREMENT = 30; // Minimum value for color components, controls color saturation int MIN = 50; @@ -27,7 +27,7 @@ int MIN = 50; // Singleton instance ColorGenerator* ColorGenerator::instance = nullptr_t(); -ColorGenerator::ColorGenerator():red{255}, green {0}, blue{50}, min{MIN}, token {0} +ColorGenerator::ColorGenerator():red{255}, green {MIN}, blue{MIN}, min{MIN}, token {0} { } @@ -38,16 +38,19 @@ ColorGenerator* ColorGenerator::getInstance() } // Update color value based on comparison color -int ColorGenerator::updateColor(int color, int comparison_color){ - if (token == 2 && this->red > 249 && this->greenbluemin+=COLOR_INCREMENT; - else{ - this->red=189; - this->green=189; - this->blue=189; - this->token = 3; - return 189; - } +int ColorGenerator::updateColor(int color, int comparison_color){ + if (token == 4 || (token == 2 && this->red == 255 && this->green >= min-COLOR_INCREMENT && this->blue == min)){ + if(min<255-2*COLOR_INCREMENT) { + this->min+=COLOR_INCREMENT; + return color-=COLOR_INCREMENT; + } + else{ + this->red=250; + this->green=250; + this->blue=250; + this->token = 4; + return 250; + } } @@ -60,7 +63,7 @@ if (comparison_color==min){ } }else{ - if ((color-COLOR_INCREMENT)>min-1) return color-=COLOR_INCREMENT; + if ((color-COLOR_INCREMENT)>=min) return color-=COLOR_INCREMENT; else{ this->token = (token +1)%3; return min; @@ -73,30 +76,27 @@ if (comparison_color==min){ QColor ColorGenerator::GetNewColor(){ QColor color; switch(token){ - // Update red value + // Update red value case 1: color = QColor(red,green,blue); this->red=updateColor(red,blue); - if(token == 2) this->green=updateColor(green,red); break; - // Update green value + // Update green value case 2: color = QColor(red,green,blue); this->green=updateColor(green,red); - if(token==0) this->blue=updateColor(blue,green); break; // Update blue value case 0: color = QColor(red,green,blue); - this->blue = updateColor(blue,green); - if(token==1) this->red=updateColor(red,blue); + this->blue = updateColor(blue,green); break; - default: - color = colors::COLOR_SLOT_PLAIN; + default: + color = QColor::fromRgb(0xFAFAFA); break; } return color; @@ -105,8 +105,8 @@ QColor ColorGenerator::GetNewColor(){ void ColorGenerator::setDefault(){ this->red=255; - this->green=0; - this->blue=50; + this->green=MIN; + this->blue=MIN; this->min=MIN; this->token=0; } diff --git a/src/ui/ColorGenerator.hpp b/src/ui/ColorGenerator.hpp index a5dac1a..f0e38c5 100644 --- a/src/ui/ColorGenerator.hpp +++ b/src/ui/ColorGenerator.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/ui/ColorSynchronizer.cpp b/src/ui/ColorSynchronizer.cpp index 1c12370..fd7ceeb 100644 --- a/src/ui/ColorSynchronizer.cpp +++ b/src/ui/ColorSynchronizer.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -39,7 +39,7 @@ void ColorSynchronizer::synchronizeColors(const std::string& function, const QCo if(slot->region->name().str()==function) slot->setColor(color); } } - data_->colorChanged(); + Q_EMIT data_->colorChanged(); } void ColorSynchronizer::synchronizeColors(const QColor& color, bool all){ @@ -55,7 +55,7 @@ void ColorSynchronizer::synchronizeColors(const QColor& color, bool all){ } } } - data_->colorChanged(); + Q_EMIT data_->colorChanged(); } @@ -69,7 +69,7 @@ void ColorSynchronizer::synchronizeColors(){ slot->setColor(map->getColor(function_)); } } - data_->colorChanged(); + Q_EMIT data_->colorChanged(); } void ColorSynchronizer::reCalculateColors(){ @@ -100,7 +100,7 @@ void ColorSynchronizer::reCalculateColors(){ } } } - data_->colorChanged(); + Q_EMIT data_->colorChanged(); } diff --git a/src/ui/ColorSynchronizer.hpp b/src/ui/ColorSynchronizer.hpp index 8e3d37d..297b129 100644 --- a/src/ui/ColorSynchronizer.hpp +++ b/src/ui/ColorSynchronizer.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/ui/ScrollSynchronizer.cpp b/src/ui/ScrollSynchronizer.cpp index 5a19651..ec7eb3b 100644 --- a/src/ui/ScrollSynchronizer.cpp +++ b/src/ui/ScrollSynchronizer.cpp @@ -20,7 +20,6 @@ #include ScrollSynchronizer::ScrollSynchronizer(QObject *parent) : QObject(parent) { - } void ScrollSynchronizer::addWidget(QAbstractScrollArea *newWidget) { @@ -28,8 +27,9 @@ void ScrollSynchronizer::addWidget(QAbstractScrollArea *newWidget) { return; } for (const auto &widget : this->widgets) { + // Classic connect(widget->verticalScrollBar(), &QScrollBar::valueChanged, newWidget->verticalScrollBar(), &QScrollBar::setValue); connect(newWidget->verticalScrollBar(), &QScrollBar::valueChanged, widget->verticalScrollBar(), &QScrollBar::setValue); } this->widgets.push_back(newWidget); -} +} \ No newline at end of file diff --git a/src/ui/TraceDataProxy.cpp b/src/ui/TraceDataProxy.cpp index 888d3ed..b77f963 100644 --- a/src/ui/TraceDataProxy.cpp +++ b/src/ui/TraceDataProxy.cpp @@ -54,7 +54,6 @@ ViewSettings *TraceDataProxy::getSettings() const { return settings; } - types::TraceTime TraceDataProxy::getTotalRuntime() const { return trace->getRuntime(); } diff --git a/src/ui/TraceDataProxy.hpp b/src/ui/TraceDataProxy.hpp index e80d866..5a24697 100644 --- a/src/ui/TraceDataProxy.hpp +++ b/src/ui/TraceDataProxy.hpp @@ -115,6 +115,19 @@ public: Q_SIGNALS: */ void filterChanged(Filter); + void verticalZoomChanged(); + + void refreshOverviewRequest(); + + void refreshButtonPressed(); + + void flamegraphRequest(); + + void hideSlidersBoxRequest(); + + void triggerUITimerStartIfPossible(); + void triggerUITimerEndIfPossible(); + public Q_SLOTS: /** * Change the start time of the selection diff --git a/src/ui/views/FlamegraphView.cpp b/src/ui/views/FlamegraphView.cpp new file mode 100644 index 0000000..b72fca9 --- /dev/null +++ b/src/ui/views/FlamegraphView.cpp @@ -0,0 +1,320 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "TimelineView.hpp" +#include "FlamegraphView.hpp" +#include "src/models/ViewSettings.hpp" +#include "src/ui/views/CommunicationIndicator.hpp" +#include "src/ui/views/SlotIndicator.hpp" +#include "src/ui/Constants.hpp" +#include "CollectiveCommunicationIndicator.hpp" +#include "src/ui/ColorGenerator.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + + +FlamegraphView::FlamegraphView(TraceDataProxy *data, QWidget *parent) : QGraphicsView(parent), data(data) { + auto scene = new QGraphicsScene(); + this->setAlignment(Qt::AlignTop | Qt::AlignLeft); + this->setAutoFillBackground(false); + this->setStyleSheet("background: transparent"); + this->setScene(scene); + this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + this->requestedRank = ViewSettings::getInstance()->getFlamegraphRankRef(); + this->globalMaxHeight = 0; + + // @formatter:off + connect(this->data, SIGNAL(selectionChanged(types::TraceTime,types::TraceTime)), this, SLOT(updateView())); + connect(this->data, SIGNAL(filterChanged(Filter)), this, SLOT(updateView())); + connect(this->data, SIGNAL(colorChanged()),this, SLOT(updateView())); + connect(this->data, SIGNAL(verticalZoomChanged()),this,SLOT(updateView())); + connect(this->data, SIGNAL(refreshButtonPressed()),this,SLOT(updateView())); + // @formatter:on +} + + +void FlamegraphView::populateScene(QGraphicsScene *scene) { + QElapsedTimer populateSceneTimer; + populateSceneTimer.start(); + auto width = scene->width(); + auto selection = this->data->getSelection(); + auto runtime = selection->getRuntime().count(); + auto begin = this->data->getBegin().count(); + auto end = begin + runtime; + int allSlotsCount=0; + std::multiset allSlotsMultiset{}; + int drawnSlotsCount=0; + std::multiset drawnSlotsMultiset{}; + + QPen arrowPen(Qt::black, 1); + QPen collectiveCommunicationPen(colors::COLOR_COLLECTIVE_COMMUNICATION, 2); + + auto onTimedElementSelected = [this](TimedElement *element) { this->data->setTimeElementSelection(element); }; + auto onTimedElementDoubleClicked = [this](TimedElement *element) { + this->data->setSelection(element->getStartTime(), element->getEndTime()); + }; + + unsigned top = 0; + unsigned int baseRowLevel = 0; + unsigned int localMaxHeight = 0; + this->globalMaxHeight=0; + + auto * settings = ViewSettings::getInstance(); + auto ROW_HEIGHT = settings->getRowHeight(); + int threadDrawOffset = ROW_HEIGHT*2.2; + auto * rankThreadMap = settings->getRankThreadMap(); + auto * rankAdrMap = settings->getRankAdrMap(); + auto rank = settings->getRankAdrMap()->at(this->requestedRank); + + bool countIndicatorDetailsFlamegraph = settings->getCountIndicatorDetailsFlamegraph(); + bool pxThresholdFlamegraph = settings->getPxThresholdFlamegraph(); + bool useRealWidth = settings->getUseRealWidthFlamegraph(); + + std::string rankNameStd = rank->name().str(); + auto rankName = QString::fromStdString(rankNameStd); + + const auto reqRankAdr = rankAdrMap->at(this->requestedRank); + + if(countIndicatorDetailsFlamegraph){ + // What's the 'real' number of slots for this particular rank? + auto rawSlots = this->data->getFullTrace()->subtrace(this->data->getBegin(), this->data->getEnd())->getSlots().at(reqRankAdr); + for(auto entry : rawSlots){ + allSlotsCount++; + allSlotsMultiset.insert(entry->region->name().get()->str()); + } + } + + // Preparation + int threadCount = rankThreadMap->at(reqRankAdr->ref().get()).second.size(); + std::vector threadRefVector(threadCount, std::to_string(0)); + for (const auto& [threadRef, threadInfo]: rankThreadMap->at(reqRankAdr->ref().get()).second) { + // First threadRef has to go to index 0 etc. + threadRefVector[threadInfo.first-1]=threadRef; + } + + for (int i = 0; i < threadCount; i++) { + + std::string threadName = ""; + int drawnSlotsCountLocal = 0; + bool firstSlot = true; + + // We want to shift the baselevel-hight if we start to draw another thread + baseRowLevel=this->globalMaxHeight; + + // That's where we store the information regarding our row-level + std::vector endtimeVector{}; + const auto reqSlots = data->getSelection()->getSlots().at(reqRankAdr); + for (const auto &Slot: reqSlots) { + auto threadRef = std::to_string(Slot->location->ref().get()); + if (!(threadRef == threadRefVector[i])) continue; + // We need some initial limit + //if(endtimeVector.empty())endtimeVector.push_back(Slot->getEndTime().count()); + if (threadName=="")threadName=Slot->location->name().str(); + auto region = Slot->region; + auto regionName = region->name(); + auto regionNameStr = regionName.str(); + auto startTime = Slot->startTime.count(); + auto endTime = Slot->endTime.count(); + + // Ensures slots starting before `begin` (like main) are considered to start at begin + auto effectiveStartTime = qMax(begin, startTime); + // Ensures slots ending after `end` (like main) are considered to end at end + auto effectiveEndTime = qMin(end, endTime); + + auto slotBeginPos = (static_cast(effectiveStartTime - begin) / static_cast(runtime)) * width; + auto slotRuntime = static_cast(effectiveEndTime - effectiveStartTime); + auto rectWidth = (slotRuntime / static_cast(runtime)) * width; + + // There has to be some minimal size for the indicators, or else we will get false hierarchies + if(pxThresholdFlamegraph && rectWidth<1) continue; + + if(!useRealWidth) rectWidth = qMax(rectWidth, 5.0); + + // Are we within the limits of our last frame? + if(endtimeVector.empty() || endTime <= endtimeVector.back()){ + endtimeVector.push_back(endTime); + } + // Otherwise we have to scale down until we encounter a frame beneath us, that has a bigger endTime + else{ + while(!endtimeVector.empty() && endTime > endtimeVector.back()){ + endtimeVector.pop_back(); + } + if(endtimeVector.empty() || endTime <= endtimeVector.back()){ + endtimeVector.push_back(endTime); + } + } + top=threadDrawOffset+baseRowLevel+ROW_HEIGHT*(endtimeVector.size()-1); + if(top>localMaxHeight)localMaxHeight=top; + + QRectF rect(slotBeginPos, top, rectWidth, ROW_HEIGHT); + auto rectItem = new SlotIndicator(rect, Slot); + + rectItem->setOnDoubleClick(onTimedElementDoubleClicked); + rectItem->setOnSelected(onTimedElementSelected); + rectItem->setToolTip(Slot->location->name().str().c_str()); + + + QGraphicsTextItem *text = new QGraphicsTextItem(rectItem); + QFontMetrics fm(text->font()); + QString elidedText = fm.elidedText(regionNameStr.c_str(), Qt::ElideRight, rectItem->rect().width()); + text->setPlainText(elidedText); + qreal x = rectItem->rect().center().x() - text->boundingRect().width() / 2; + qreal y = rectItem->rect().center().y() - text->boundingRect().height() / 2; + text->setPos(x,y); + text->setTextInteractionFlags(Qt::NoTextInteraction); + text->setTextWidth(rectItem->rect().width()); + text->setParentItem(rectItem); + + if(firstSlot){ + firstSlot=false; + QGraphicsTextItem *threadDscr = new QGraphicsTextItem(rectItem); + QFont font; + font.setPointSize(10); + font.setItalic(true); + threadDscr->setFont(font); + threadDscr->setDefaultTextColor(Qt::darkGray); + threadDscr->setPlainText(threadName.c_str()); + // Slightly above the Slot + y = rectItem->rect().center().y() - (ROW_HEIGHT/2.0 + 20); + threadDscr->setPos(slotBeginPos,y); + threadDscr->setTextInteractionFlags(Qt::NoTextInteraction); + threadDscr->setParentItem(rectItem); + } + + // Determine color based on name + rectItem->setBrush(Slot->getColor()); + rectItem->setZValue(Slot->priority); + drawnSlotsCountLocal++; + drawnSlotsMultiset.insert(regionNameStr); + scene->addItem(rectItem); + } + drawnSlotsCount+=drawnSlotsCountLocal; + + // That's relevant for the scene height in updates + if(localMaxHeight>this->globalMaxHeight)this->globalMaxHeight=localMaxHeight; + } + + // That's the infoBar (QStatusBar) logic + QString infoStructure; + if(countIndicatorDetailsFlamegraph){ + infoStructure =rankName+(" --- drawn items "+std::to_string(drawnSlotsCount)+"/"+std::to_string(allSlotsCount)).c_str(); + infoStructure+=(" in "+std::to_string(populateSceneTimer.elapsed())+"[ms]").c_str(); + std::map difference{}; + for (std::string name : allSlotsMultiset) { + int countDrawn = drawnSlotsMultiset.count(name); + int countExisting = allSlotsMultiset.count(name); + int diff = countExisting - countDrawn; + if(diff!=0)difference.insert_or_assign(name, diff); + } + QFontMetrics fm(this->font()); + auto capacity = this->sceneRect().width() - fm.boundingRect(infoStructure).width(); + if(difference.size()>0){ + infoStructure+=" --- not drawn: "; + for (auto diffPair : difference) { + QString extraInfo = (diffPair.first+" *"+std::to_string(diffPair.second)+"times ").c_str(); + if(capacity > 300){ + infoStructure+=extraInfo; + capacity-=fm.boundingRect(extraInfo).width(); + } + else{ + infoStructure+=", and more ..."; + break; + } + } + } + } + else{ + infoStructure+=(std::to_string(populateSceneTimer.elapsed())+"[ms]").c_str(); + } + this->statusInfo=infoStructure; + statusChanged(); +} + +void FlamegraphView::resizeEvent(QResizeEvent *event) { + auto rectVal = this->rect(); + // We don't want to make the scene height depandand on the window height + //rectVal.setHeight(this->scene()->height()); + //this->scene()->setSceneRect(rectVal); + this->updateView(); + rectVal.setHeight(this->getGlobalMaxHeight()); + this->scene()->setSceneRect(rectVal); + QGraphicsView::resizeEvent(event); +} + +void FlamegraphView::updateView() { + // If we close the popup window for this particular view its status will be set to hidden + // The second check for the statusInfo legnth prevents unwanted deletion during the object construction + if(this->parentWidget()->isHidden() && this->statusInfo.length()>0){ + delete this->parentWidget(); + } + else{ + this->scene()->clear(); + this->populateScene(this->scene()); + } +} + +void FlamegraphView::wheelEvent(QWheelEvent *event) { + // Calculation according to https://doc.qt.io/qt-6/qwheelevent.html#angleDelta: + // @c angleDelta is in eights of a degree and most mouse wheels work in steps of 15 degrees. + QPoint numDegrees = event->angleDelta() / 8; + + if (!numDegrees.isNull() && QApplication::keyboardModifiers() & (Qt::CTRL | Qt::SHIFT)) { + // See documentation and comment above + QPoint numSteps = numDegrees / 15; + auto stepSize = data->getSelection()->getRuntime() / data->getSettings()->getZoomQuotient(); + auto deltaDuration = stepSize * numSteps.y(); + auto delta = static_cast(deltaDuration.count()); + + types::TraceTime newBegin; + types::TraceTime newEnd; + if (QApplication::keyboardModifiers() == Qt::CTRL) { + // Calculate the position of the mouse relative to the scene to zoom to where the mouse is pointed + auto originFactor = event->scenePosition().x() / this->scene()->width(); + + auto leftDelta = types::TraceTime(static_cast(originFactor * 2 * delta)); + auto rightDelta = types::TraceTime(static_cast((1 - originFactor) * 2 * delta)); + + newBegin = data->getSelection()->getStartTime() + leftDelta; + newEnd = data->getSelection()->getStartTime() + data->getSelection()->getRuntime() - rightDelta; + } else { + // Calculate new absolute times (might be negative or to large) + auto newBeginAbs = data->getSelection()->getStartTime() - deltaDuration; + auto newEndAbs = data->getSelection()->getStartTime() + data->getSelection()->getRuntime() - deltaDuration; + + // Limit the times to their boundaries (0 for start and end of entire trace for end) + auto newBeginBounded = qMax(newBeginAbs, types::TraceTime(0)); + auto newEndBounded = qMin(newEndAbs, data->getTotalRuntime()); + + // If one time exceeds the bounds reject the changes + newBegin = qMin(newBeginBounded, newEndBounded - data->getSelection()->getRuntime()); + newEnd = qMax(newEndBounded, newBeginBounded + data->getSelection()->getRuntime()); + } + + data->setSelection(newBegin, newEnd); + event->accept(); + } else { + QGraphicsView::wheelEvent(event); + } +} \ No newline at end of file diff --git a/src/ui/views/FlamegraphView.hpp b/src/ui/views/FlamegraphView.hpp new file mode 100644 index 0000000..55ec256 --- /dev/null +++ b/src/ui/views/FlamegraphView.hpp @@ -0,0 +1,87 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#ifndef MOTIV_FLAMEGRAPHVIEW_HPP +#define MOTIV_FLAMEGRAPHVIEW_HPP + + +#include + +#include "src/ui/TraceDataProxy.hpp" +//#include "src/ui/views/ColorGenerator.hpp" + +/** + * @brief The main view component rendering the trace + * + * This class is the main component responsible for rendering all slots, communications and collective communications. + * The scene is rerendered whenever the selected time window of the trace changes or the window is resized. + */ +class FlamegraphView : public QGraphicsView { +Q_OBJECT + +public: + /** + * @brief Creates a new instance of the FlamegraphView class. + * + * @param data The data proxy to obtain the current selection of the trace and to connect to change events + * @param parent The parent QWidget + */ + explicit FlamegraphView(TraceDataProxy *data, QWidget *parent = nullptr); + QString statusInfo; + auto getRequestedRank(){ return requestedRank; } + auto getGlobalMaxHeight(){ return globalMaxHeight; } + +public: Q_SIGNALS: + /** + * @brief Indicates a TimedElement is selected. + * + * @param begin The start time of the selected TimedElement + * @param end The end time of the selected TimedElement + */ + void elementSelected(types::TraceTime begin, types::TraceTime end); + void statusChanged(); + +public Q_SLOTS: + + /** + * @brief Updates the view to reflect the current selection of the TraceDataProxy. + */ + void updateView(); + +protected: + /** + * @copydoc QGraphicsView::resizeEvent(QResizeEvent*) + */ + void resizeEvent(QResizeEvent *event) override; + + /** + * @copydoc QGraphicsView::wheelEvent(QWheelEvent*) + */ + void wheelEvent(QWheelEvent *event) override; + +private: + void populateScene(QGraphicsScene *element); + +private: + TraceDataProxy *data = nullptr; + unsigned int requestedRank; + unsigned int globalMaxHeight; + // ColorGenerator colorgenerator; +}; + + +#endif //MOTIV_FLAMEGRAPHVIEW_HPP diff --git a/src/ui/views/GenericIndicator.cpp b/src/ui/views/GenericIndicator.cpp index f3149d0..2104f80 100644 --- a/src/ui/views/GenericIndicator.cpp +++ b/src/ui/views/GenericIndicator.cpp @@ -86,4 +86,5 @@ void GenericIndicator::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) { template class GenericIndicator; template class GenericIndicator; +template class GenericIndicator; template class GenericIndicator; diff --git a/src/ui/views/NodeIndicator.cpp b/src/ui/views/NodeIndicator.cpp new file mode 100644 index 0000000..f75d80c --- /dev/null +++ b/src/ui/views/NodeIndicator.cpp @@ -0,0 +1,30 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "NodeIndicator.hpp" + +#include +#include + + +#include "src/ui/Constants.hpp" + +NodeIndicator::NodeIndicator(Slot *representedSlot, qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent) + : GenericIndicator(representedSlot, parent) { + this->setRect(x, y, w, h); + } diff --git a/src/ui/views/NodeIndicator.hpp b/src/ui/views/NodeIndicator.hpp new file mode 100644 index 0000000..110d9ad --- /dev/null +++ b/src/ui/views/NodeIndicator.hpp @@ -0,0 +1,47 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_NODEINDICATOR_HPP +#define MOTIV_NODEINDICATOR_HPP + +#include + +#include "src/ui/TraceDataProxy.hpp" +#include "src/models/Slot.hpp" +#include "src/types.hpp" +#include "GenericIndicator.hpp" + + +/** + * @brief Indicator for collective communications + * + * A slot is indicated by a rectangle. + */ +class NodeIndicator : public GenericIndicator { +public: // constructors + /** + * @brief Creates a new instance of the SlotIndicator class + * @param rect The rect the slot should be rendered + * @param representedSlot The Slot object the indicator is representing + * @param parent The parent QGraphicsItem + */ + NodeIndicator(Slot *representedSlot, qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = nullptr); +}; + + +#endif //MOTIV_NODEINDICATOR_HPP \ No newline at end of file diff --git a/src/ui/views/TimelineView.cpp b/src/ui/views/TimelineView.cpp index b50718c..1886b38 100644 --- a/src/ui/views/TimelineView.cpp +++ b/src/ui/views/TimelineView.cpp @@ -1,6 +1,9 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, + * Björn Gehrke, + * Jessica Lafontaine, + * Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -16,15 +19,23 @@ * along with this program. If not, see . */ #include "TimelineView.hpp" +#include "src/models/ViewSettings.hpp" #include "src/ui/views/CommunicationIndicator.hpp" #include "src/ui/views/SlotIndicator.hpp" #include "src/ui/Constants.hpp" #include "CollectiveCommunicationIndicator.hpp" #include "src/ui/ColorGenerator.hpp" +#include +#include +#include #include #include #include +#include +#include +#include + TimelineView::TimelineView(TraceDataProxy *data, QWidget *parent) : QGraphicsView(parent), data(data) { auto scene = new QGraphicsScene(); @@ -37,13 +48,17 @@ TimelineView::TimelineView(TraceDataProxy *data, QWidget *parent) : QGraphicsVie // @formatter:off connect(this->data, SIGNAL(selectionChanged(types::TraceTime,types::TraceTime)), this, SLOT(updateView())); connect(this->data, SIGNAL(filterChanged(Filter)), this, SLOT(updateView())); - connect(this->data, SIGNAL(colorChanged()),this, SLOT(updateView())); + //connect(this->data, SIGNAL(colorChanged()),this, SLOT(updateView())); + connect(this->data, SIGNAL(verticalZoomChanged()),this,SLOT(updateView())); + connect(this->data, SIGNAL(refreshButtonPressed()),this,SLOT(updateView())); // @formatter:on } void TimelineView::populateScene(QGraphicsScene *scene) { - auto width = scene->width(); + this->data->triggerUITimerStartIfPossible(); + // This -5 offset removes the tiny scrollable area to the right + auto width = scene->width() - 5; auto selection = this->data->getSelection(); auto runtime = selection->getRuntime().count(); auto runtimeR = static_cast(runtime); @@ -52,121 +67,255 @@ void TimelineView::populateScene(QGraphicsScene *scene) { auto end = begin + runtime; auto endR = static_cast(end); + std::array globalDrawCount{}; + std::array globalFullCount{}; + QPen arrowPen(Qt::black, 1); QPen collectiveCommunicationPen(colors::COLOR_COLLECTIVE_COMMUNICATION, 2); - auto onTimedElementSelected = [this](TimedElement *element) { this->data->setTimeElementSelection(element); }; auto onTimedElementDoubleClicked = [this](TimedElement *element) { this->data->setSelection(element->getStartTime(), element->getEndTime()); }; + + auto top = 20; + auto settings = ViewSettings::getInstance(); + auto ROW_HEIGHT = settings->getRowHeight(); + auto * rankThreadMap = settings->getRankThreadMap(); + std::string searchName_ = settings->getSearchName().toStdString(); + + auto countIndicatorsREG = settings->getCountIndicatorsREG(); + auto countIndicatorsP2P = settings->getCountIndicatorsP2P(); + auto countIndicatorsCCM = settings->getCountIndicatorsCCM(); + auto usePriority = settings->getUsePriorityOverview(); + auto useRealWidth = settings->getUseRealWidthMainWindow(); + auto useAbsoluteDurationsForSliders = settings->getAbsoluteDurationsForSliders(); + + auto activeThresholdREG = settings->getActiveThresholdREG(); + auto activeThresholdP2P = settings->getActiveThresholdP2P(); + auto activeThresholdCCM = settings->getActiveThresholdCCM(); - auto top = 20; - auto ROW_HEIGHT = 30; for (const auto &item: selection->getSlots()) { - // Display slots - for (const auto &slot: item.second) { - if (!(slot->getKind() & data->getSettings()->getFilter().getSlotKinds())) continue; - - auto region = slot->region; - auto regionName = region->name(); - auto regionNameStr = regionName.str(); - auto startTime = slot->startTime.count(); - auto endTime = slot->endTime.count(); - - // Ensures slots starting before `begin` (like main) are considered to start at begin - auto effectiveStartTime = qMax(begin, startTime); - // Ensures slots ending after `end` (like main) are considered to end at end - auto effectiveEndTime = qMin(end, endTime); - - auto slotBeginPos = (static_cast(effectiveStartTime - begin) / static_cast(runtime)) * width; - auto slotRuntime = static_cast(effectiveEndTime - effectiveStartTime); - auto rectWidth = (slotRuntime / static_cast(runtime)) * width; - - QRectF rect(slotBeginPos, top, qMax(rectWidth, 5.0), ROW_HEIGHT); - auto rectItem = new SlotIndicator(rect, slot); - rectItem->setOnDoubleClick(onTimedElementDoubleClicked); - rectItem->setOnSelected(onTimedElementSelected); - rectItem->setToolTip(regionNameStr.c_str()); - - // Determine color based on name - rectItem->setBrush(slot->getColor()); - rectItem->setZValue(slot->priority); - scene->addItem(rectItem); - - /* - QColor rectColor = slot->color; - - - - switch (slot->getKind()) { - case ::MPI: - rectColor = colors::COLOR_SLOT_MPI; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 2); - break; - case ::OpenMP: - rectColor = colors::COLOR_SLOT_OPEN_MP; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 1); - break; - case ::None: - case ::Plain: - default: - rectColor = colors::COLOR_SLOT_PLAIN; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 0); - break; + auto rankNameStd = item.first->name().str(); + auto rankName = QString::fromStdString(rankNameStd); + + int localDrawCount = 0; + if(countIndicatorsREG) { + auto rawSLTs = this->data->getFullTrace()->subtrace(this->data->getBegin(), this->data->getEnd())->getSlots().at(item.first); + for(auto SLT : rawSLTs){ + globalFullCount[0]++; } + } + + // Do we have the thread view expanded? + auto toggleStatus = rankThreadMap->at(item.first->ref().get()).first; + int threadCount = rankThreadMap->at(item.first->ref().get()).second.size(); - rectItem->setBrush(rectColor); - scene->addItem(rectItem); - */ + // Preparation + std::vector threadRefVector(threadCount, std::to_string(0)); + for (const auto& [threadRef, threadInfo]: rankThreadMap->at(item.first->ref().get()).second) { + // First threadRef has to go to index 0 etc. + threadRefVector[threadInfo.first-1]=threadRef; } - top += ROW_HEIGHT; + // Draw slots + for (int i = 0; i < threadCount; i++) { + for (const auto &slot: item.second) { + // Do we really want to draw this slot? + if (!(slot->getKind() & data->getSettings()->getFilter().getSlotKinds())) continue; + // Does it belong to the currently drawn thread? + auto threadRef = std::to_string(slot->location->ref().get()); + if (!(threadRef == threadRefVector[i])) continue; + auto region = slot->region; + auto regionName = region->name(); + auto regionNameStr = regionName.str(); + auto startTime = slot->startTime.count(); + auto endTime = slot->endTime.count(); + + // Ensures slots starting before `begin` (like main) are considered to start at begin + auto effectiveStartTime = qMax(begin, startTime); + // Ensures slots ending after `end` (like main) are considered to end at end + auto effectiveEndTime = qMin(end, endTime); + + if(activeThresholdREG){ + double regLength = 0; + useAbsoluteDurationsForSliders ? regLength = endTime - startTime : regLength = effectiveEndTime - effectiveStartTime; + double timeFraction = (runtime/1000.0) * activeThresholdREG; + if(regLength(effectiveStartTime - begin) / static_cast(runtime)) * width; + auto slotRuntime = static_cast(effectiveEndTime - effectiveStartTime); + auto rectWidth = (slotRuntime / static_cast(runtime)) * width; + + if(!useRealWidth) rectWidth = qMax(rectWidth, 5.0); + + QRectF rect(slotBeginPos, top, rectWidth, ROW_HEIGHT); + auto rectItem = new SlotIndicator(rect, slot); + rectItem->setOnDoubleClick(onTimedElementDoubleClicked); + rectItem->setOnSelected(onTimedElementSelected); + //rectItem->setToolTip(slot->location->name().str().c_str()); + rectItem->setToolTip(regionNameStr.c_str()); + + // Determine color based on name + QColor rectColor = slot->getColor(); + rectItem->setBrush(rectColor); + + // Set search filter + if(searchName_!= ""){ + if(searchName_ != slot->region->name().str()){ + rectItem->setBrush(colors::COLOR_SLOT_PLAIN); + } else rectItem->setZValue(20); + + } else rectItem->setZValue(usePriority ? slot->priority : 1/rectWidth); + scene->addItem(rectItem); + localDrawCount++; + } + + if(toggleStatus){ + top += ROW_HEIGHT; + } + } + if(!toggleStatus){ + top += ROW_HEIGHT; + } + globalDrawCount[0]+=localDrawCount; } - for (const auto &communication: selection->getCommunications()) { + for (const auto &communication: selection->getCommunications()) { const CommunicationEvent *startEvent = communication->getStartEvent(); + if (!((startEvent->getKind() & data->getSettings()->getFilter().getCommunicationKinds())==startEvent->getKind())) continue; auto startEventEnd = static_cast(startEvent->getEndTime().count()); auto startEventStart = static_cast(startEvent->getStartTime().count()); const CommunicationEvent *endEvent = communication->getEndEvent(); - auto endEventEnd = static_cast(startEvent->getEndTime().count()); - auto endEventStart = static_cast(startEvent->getStartTime().count()); + auto endEventEnd = static_cast(endEvent->getEndTime().count()); + auto endEventStart = static_cast(endEvent->getStartTime().count()); + // With the new support for threads we have also to consider the thread-location (fromThread, to Thread) + auto fromRank = startEvent->getLocation()->location_group().ref().get(); + auto fromThreadRef = startEvent->getLocation()->ref().get(); + auto toRank = endEvent->getLocation()->location_group().ref().get(); + auto toThreadRef = endEvent->getLocation()->ref().get(); + + // Is the P2P communication toggled? + if(rankThreadMap->at(fromRank).second.at(std::to_string(fromThreadRef)).second.at(1)) continue; + if(rankThreadMap->at(toRank).second.at(std::to_string(toThreadRef)).second.at(1)) continue; + auto fromTime = startEventStart + (startEventEnd - startEventStart) / 2; auto effectiveFromTime = qMax(beginR, fromTime) - beginR; auto toTime = endEventStart + (endEventEnd - endEventStart) / 2; auto effectiveToTime = qMin(endR, toTime) - beginR; + if(activeThresholdP2P){ + double commLength = 0; + useAbsoluteDurationsForSliders ? commLength = toTime - fromTime : commLength = effectiveToTime - effectiveFromTime; + double timeFraction = (runtime/1000.0) * activeThresholdP2P; + if(commLengthgetLocation()->ref().get(); - auto toRank = endEvent->getLocation()->ref().get(); + auto toRank = endEvent->getLocation()->ref().get(); + + We changed it based on the assumption that: + location <=> Thread + location group <=> Rank + (Page 4, MOTIV Report) + */ + + // Correction if we point from and/or to somthing else than a mainthread (=> -1) + bool fromToggleStatus = rankThreadMap->at(fromRank).first; + int fromThreadNumber = rankThreadMap->at(fromRank).second.at(std::to_string(fromThreadRef)).first; + bool toToggleStatus = rankThreadMap->at(toRank).first; + int toThreadNumber = rankThreadMap->at(toRank).second.at(std::to_string(toThreadRef)).first; + int fromThreadOffset = fromToggleStatus*(fromThreadNumber-1)*ROW_HEIGHT; + int toThreadOffset = toToggleStatus*(toThreadNumber-1)*ROW_HEIGHT; + + int higherPos = 0; + int lowerPos = 0; + QString currentRank; + // the arrow points to the bottom + toRank > fromRank ? (higherPos=fromRank, lowerPos=toRank) : (higherPos=toRank, lowerPos=fromRank); + + // How many threads were rendered above the arrow? + // Idea: We only accumulate the offset from positions above (<=> lower ranks) higherPos => higherPos-1 + int higherOffset = 0; + for (int i = higherPos-1; i >= 0; i--) { + // Do we have the thread view expanded? + bool toggleStatus = rankThreadMap->at(i).first; + // How many Threads are there? apart from the main thread => -1 + int threadCount = rankThreadMap->at(i).second.size()-1; + higherOffset += toggleStatus*threadCount*ROW_HEIGHT; + } + + // How many threads were rendered extra within the arrow? + // Idea: The same as for higherOffset + int innerOffset = 0; + for (int i = lowerPos-1; i >= higherPos; i--) { + // Do we have the thread view expanded? + bool toggleStatus = rankThreadMap->at(i).first; + // How many Threads are there? apart from the main thread => -1 + int threadCount = rankThreadMap->at(i).second.size()-1; + innerOffset += toggleStatus*threadCount*ROW_HEIGHT; + } + + int fromOffset = 0; + int toOffset = 0; + + // if the arrow points to the bottom (higher ranks are rendered lower) we have to use the toOffset as the sum of higherOffset and innerOffset + toRank > fromRank ? (toOffset=higherOffset+innerOffset+toThreadOffset, fromOffset=higherOffset+fromThreadOffset) : (toOffset=higherOffset+toThreadOffset, fromOffset=higherOffset+innerOffset+fromThreadOffset); + + auto rankNameFrom = startEvent->getLocation()->location_group().name().str(); + auto threadNameFrom = startEvent->getLocation()->name().str(); + auto rankNameTo = endEvent->getLocation()->location_group().name().str(); + auto threadNameTo = endEvent->getLocation()->name().str(); + + + QString Info = QString::fromStdString("From:\t"+rankNameFrom+" @ "+threadNameFrom+"\nTo:\t"+rankNameTo+" @ "+threadNameTo); auto fromX = effectiveFromTime / runtimeR * width; - auto fromY = static_cast(fromRank * ROW_HEIGHT) + .5 * ROW_HEIGHT + 20; + auto fromY = static_cast(fromRank * ROW_HEIGHT) + .5 * ROW_HEIGHT + 20 + fromOffset; auto toX = effectiveToTime / runtimeR * width; - auto toY = static_cast (toRank * ROW_HEIGHT) + .5 * ROW_HEIGHT + 20; + auto toY = static_cast (toRank * ROW_HEIGHT) + .5 * ROW_HEIGHT + 20 + toOffset; auto arrow = new CommunicationIndicator(communication, fromX, fromY, toX, toY); arrow->setOnSelected(onTimedElementSelected); arrow->setOnDoubleClick(onTimedElementDoubleClicked); arrow->setPen(arrowPen); arrow->setZValue(layers::Z_LAYER_P2P_COMMUNICATIONS); + arrow->setToolTip(Info); + // Line modification, currently not used, problem: CommunicationIndicator is a QGraphicsPolygonItem (closed polygon) + //QPolygonF pointPath = arrow->polygon(); + //pointPath.insert(1, QPointF(fromX, toY)); + //arrow->setPolygon(pointPath); + scene->addItem(arrow); + globalDrawCount[1]++; } for (const auto &communication: selection->getCollectiveCommunications()) { + if (!((communication->getKind() & data->getSettings()->getFilter().getCommunicationKinds())==communication->getKind())) continue; auto fromTime = static_cast(communication->getStartTime().count()); auto effectiveFromTime = qMax(beginR, fromTime) - beginR; auto toTime = static_cast(communication->getEndTime().count()); auto effectiveToTime = qMin(endR, toTime) - beginR; + if(activeThresholdCCM){ + double commLength = 0; + useAbsoluteDurationsForSliders ? commLength = toTime - fromTime : commLength = effectiveToTime - effectiveFromTime; + double timeFraction = (runtime/1000.0) * activeThresholdCCM; + if(commLengthsetPen(collectiveCommunicationPen); rectItem->setZValue(layers::Z_LAYER_COLLECTIVE_COMMUNICATIONS); scene->addItem(rectItem); + globalDrawCount[2]++; + + for (const auto &member: communication->getMembers()){ + auto memberFromTime = static_cast(member->start.count()); + auto memberEffectiveFromTime = qMax(beginR, memberFromTime) - beginR; + + auto memberToTime = static_cast(member->end.count()); + auto memberEffectiveToTime = qMin(endR, memberToTime) - beginR; + + if(activeThresholdREG){ + double regLength = 0; + useAbsoluteDurationsForSliders ? regLength = memberToTime - memberFromTime : regLength = memberEffectiveToTime - memberEffectiveFromTime; + double timeFraction = (runtime/1000.0) * activeThresholdREG; + if(regLengthgetLocation()->location_group().ref().get(); + auto threadRef = std::to_string(member->getLocation()->ref().get()); + + // We accumulate the ROW_HEIGHTs for every expanded thread + // Hint: lower rank <=> above our current position + for (int i = rankRef-1; i >= 0; i--) { + // Do we have the thread view expanded? + bool toggleStatus = rankThreadMap->at(i).first; + // How many Threads are there? apart from the main thread => -1 + int threadCount = rankThreadMap->at(i).second.size()-1; + IndicatorOffset += toggleStatus*threadCount*ROW_HEIGHT; + } + + // Correction if the Indicator is *itself* situated within a thread + // No need to multiply with toggleStatus: main thread case => (1-1)*ROW_HEIGHT + IndicatorOffset += ((rankThreadMap->at(rankRef).second.at(threadRef).first)-1)*ROW_HEIGHT; + + auto memberFromX = (memberEffectiveFromTime / runtimeR) * width; + auto memberFromY = rankRef*ROW_HEIGHT+20+IndicatorOffset; + + auto memberToX = (memberEffectiveToTime / runtimeR) * width; + auto memberToY = top - (top - (rankRef+1)*ROW_HEIGHT)+20+IndicatorOffset; + + auto memberRectItem = new CollectiveCommunicationIndicator(communication); + memberRectItem->setOnSelected(onTimedElementSelected); + memberRectItem->setRect(QRectF(QPointF(memberFromX, memberFromY), QPointF(memberToX, memberToY))); + memberRectItem->setZValue(layers::Z_LAYER_COLLECTIVE_COMMUNICATIONS); + QBrush brush(Qt::black); + brush.setStyle(Qt::BDiagPattern); + memberRectItem->setBrush(brush); + scene->addItem(memberRectItem); + } + } + + + QString infoString; + std::string infoExtra=""; + + if(countIndicatorsREG) infoExtra="/"+std::to_string(globalFullCount[0]); + // globalFullCount was already counted on the way + infoString+=(std::to_string(globalDrawCount[0])+infoExtra+"[REG] ").c_str(); + infoExtra=""; + + if(countIndicatorsP2P) { + auto rawP2Ps = this->data->getFullTrace()->subtrace(this->data->getBegin(), this->data->getEnd())->getCommunications(); + for(auto P2P : rawP2Ps){ + globalFullCount[1]++; + } + infoExtra="/"+std::to_string(globalFullCount[1]); + } + infoString+=(std::to_string(globalDrawCount[1])+infoExtra+"[P2P] ").c_str(); + infoExtra=""; + + if(countIndicatorsCCM) { + auto rawCCMs = this->data->getFullTrace()->subtrace(this->data->getBegin(), this->data->getEnd())->getCollectiveCommunications(); + for(auto CCM : rawCCMs){ + globalFullCount[2]++; + } + infoExtra="/"+std::to_string(globalFullCount[2]); } + infoString+=(std::to_string(globalDrawCount[2])+infoExtra+"[CCM] ").c_str(); + infoExtra=""; + settings->globalMessage+=infoString; + + this->data->triggerUITimerEndIfPossible(); } void TimelineView::resizeEvent(QResizeEvent *event) { + this->data->triggerUITimerStartIfPossible(); this->updateView(); QGraphicsView::resizeEvent(event); } void TimelineView::updateView() { + this->data->triggerUITimerStartIfPossible(); // TODO it might be more performant to keep track of items and add/remove new/leaving items and resizing them this->scene()->clear(); - - auto ROW_HEIGHT = 30; + auto ROW_HEIGHT = ViewSettings::getInstance()->getRowHeight(); + auto * rankThreadMap = ViewSettings::getInstance()->getRankThreadMap(); auto sceneHeight = this->data->getSelection()->getSlots().size() * ROW_HEIGHT; + // The base offset accounts for "top" (TimelineView) and "extraSpaceBottom" (TimelineLabelList) + int sceneHeightOffset = 40; + for (const auto& [rankRef, threadMap]: *rankThreadMap) { + // calc: is the thread view expanded? * how many extra rows do we have? * ROW_HEIGHT + sceneHeightOffset+=threadMap.first*(threadMap.second.size()-1)*ROW_HEIGHT; + } auto sceneRect = this->rect(); - sceneRect.setHeight(sceneHeight); - + // The -2 offset fixes the tiny discrepancy in scrollable space between labels and scene + sceneRect.setHeight(sceneHeight+sceneHeightOffset - 2); this->scene()->setSceneRect(sceneRect); + + // We have to check wether the REG-slider is used to update the overview, and if so to update the overview + auto settings = this->data->getSettings(); + if(settings->getUseREGSliderForOV()) Q_EMIT this->data->refreshOverviewRequest(); this->populateScene(this->scene()); } @@ -241,7 +483,7 @@ void TimelineView::wheelEvent(QWheelEvent *event) { data->setSelection(newBegin, newEnd); event->accept(); + } else { + QGraphicsView::wheelEvent(event); } - - QGraphicsView::wheelEvent(event); -} +} \ No newline at end of file diff --git a/src/ui/views/TimelineView.hpp b/src/ui/views/TimelineView.hpp index cd7f0cf..fe4b69a 100644 --- a/src/ui/views/TimelineView.hpp +++ b/src/ui/views/TimelineView.hpp @@ -74,8 +74,7 @@ public Q_SLOTS: private: TraceDataProxy *data = nullptr; - // ColorGenerator colorgenerator; - + // ColorGenerator colorgenerator; }; diff --git a/src/ui/views/TraceOverviewTimelineView.cpp b/src/ui/views/TraceOverviewTimelineView.cpp index c29494d..1653827 100644 --- a/src/ui/views/TraceOverviewTimelineView.cpp +++ b/src/ui/views/TraceOverviewTimelineView.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -16,6 +16,7 @@ * along with this program. If not, see . */ #include "TraceOverviewTimelineView.hpp" +#include "src/models/ViewSettings.hpp" #include "src/ui/views/CommunicationIndicator.hpp" #include "src/ui/ColorGenerator.hpp" #include "src/ui/Constants.hpp" @@ -26,6 +27,7 @@ #include #include #include +#include TraceOverviewTimelineView::TraceOverviewTimelineView(Trace *fullTrace, QWidget *parent) : QGraphicsView(parent), fullTrace(fullTrace) { auto scene = new QGraphicsScene(this); @@ -33,6 +35,7 @@ TraceOverviewTimelineView::TraceOverviewTimelineView(Trace *fullTrace, QWidget * this->setStyleSheet("background: transparent"); this->setScene(scene); this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); selectionFrom = types::TraceTime(0); selectionTo = fullTrace->getRuntime(); @@ -47,6 +50,18 @@ void TraceOverviewTimelineView::populateScene(QGraphicsScene *scene) { qreal top = 0; auto ROW_HEIGHT = scene->height() / static_cast(uiTrace->getSlots().size()); + std::string searchName_ = ViewSettings::getInstance()->getSearchName().toStdString(); + + auto settings = ViewSettings::getInstance(); + auto useBorder = settings->getUseBorderOverview(); + auto usePriority = settings->getUsePriorityOverview(); + auto useRealWidth = settings->getUseRealWidthMainWindow(); + auto useREGSliderForOV = settings->getUseREGSliderForOV(); + double activeThresholdOV; + useREGSliderForOV ? activeThresholdOV=settings->getActiveThresholdREG() : activeThresholdOV=settings->getActiveThresholdOV(); + long usedRuntimeForThreshold; + useREGSliderForOV ? usedRuntimeForThreshold=selectionTo.count()-selectionFrom.count() : usedRuntimeForThreshold=runtime; + for (const auto &item: uiTrace->getSlots()) { // Display slots for (const auto &slot: item.second) { @@ -59,39 +74,38 @@ void TraceOverviewTimelineView::populateScene(QGraphicsScene *scene) { // Ensures slots ending after `end` (like main) are considered to end at end auto effectiveEndTime = qMin(end, endTime); + if(activeThresholdOV){ + double regLength = effectiveEndTime - effectiveStartTime; + double timeFraction = (usedRuntimeForThreshold/1000.0) * activeThresholdOV; + if(regLength(effectiveStartTime - begin) / static_cast(runtime)) * width); auto slotRuntime = static_cast(effectiveEndTime - effectiveStartTime); auto rectWidth = (slotRuntime / static_cast(runtime)) * width; - QRectF rect(slotBeginPos, top, qMax(rectWidth, 5.0), ROW_HEIGHT); + if(!useRealWidth) rectWidth = qMax(rectWidth, 5.0); + + QRectF rect(slotBeginPos, top, rectWidth, ROW_HEIGHT); auto rectItem = scene->addRect(rect); // Determine color based on name QColor rectColor = slot->getColor(); - rectItem->setZValue(slot->priority); - - /* - switch (slot->getKind()) { - case ::MPI: - rectColor = colors::COLOR_SLOT_MPI; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 2); - break; - case ::OpenMP: - rectColor = colors::COLOR_SLOT_OPEN_MP; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 1); - break; - case ::None: - case ::Plain: - default: - rectColor = colors::COLOR_SLOT_PLAIN; - rectItem->setZValue(layers::Z_LAYER_SLOTS_MIN_PRIORITY + 0); - break; - } - */ - rectItem->setBrush(rectColor); + + if(!useBorder) rectItem->setPen(Qt::NoPen); + + // Set search filter + if(searchName_!= ""){ + std::string slotName_= slot->region->name().str(); + if(searchName_ != slot->region->name().str()){ + rectItem->setBrush(colors::COLOR_SLOT_PLAIN); + } else rectItem->setZValue(20); + + } else rectItem->setZValue(usePriority ? slot->priority : 1/rectWidth); + } top += ROW_HEIGHT; @@ -115,15 +129,16 @@ void TraceOverviewTimelineView::resizeEvent(QResizeEvent *event) { QGraphicsView::resizeEvent(event); } -void TraceOverviewTimelineView::updateUITrace(){ +void TraceOverviewTimelineView::updateUITrace(){ uiTrace = UITrace::forResolution(fullTrace, window()->size().width()); - this->updateView(); + this->updateView(); } void TraceOverviewTimelineView::updateView() { this->scene()->clear(); auto sceneRect = this->rect(); + // With this -2 offset we can see all of the overview without the need to scroll sceneRect.setHeight(size().height() - 2); this->scene()->setSceneRect(sceneRect); @@ -166,7 +181,7 @@ void TraceOverviewTimelineView::mouseMoveEvent(QMouseEvent *event) rubberBand->setGeometry(QRect(rubberBandOrigin, nextPoint).normalized()); } -void TraceOverviewTimelineView::mouseReleaseEvent(QMouseEvent *) +void TraceOverviewTimelineView::mouseReleaseEvent(QMouseEvent *event) { rubberBand->hide(); diff --git a/src/ui/widgets/ColorPicker.cpp b/src/ui/widgets/ColorPicker.cpp index 4e9033a..98f78f4 100644 --- a/src/ui/widgets/ColorPicker.cpp +++ b/src/ui/widgets/ColorPicker.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/ui/widgets/ColorPicker.hpp b/src/ui/widgets/ColorPicker.hpp index fa635e4..0050230 100644 --- a/src/ui/widgets/ColorPicker.hpp +++ b/src/ui/widgets/ColorPicker.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/ui/widgets/InformationDock.cpp b/src/ui/widgets/InformationDock.cpp index 444371e..317617f 100644 --- a/src/ui/widgets/InformationDock.cpp +++ b/src/ui/widgets/InformationDock.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -112,8 +112,6 @@ void InformationDock::addElementStrategy(InformationDockElementStrategy* s) { auto infoLabel = new QLabel(tr("ⓘ")); infoLabel->setToolTip(tr("Check the box to store the colors in GlobalColors.conf")); - connect(infoLabel, SIGNAL(hovered()), infoLabel, SLOT(showToolTip())); - connect(infoLabel, SIGNAL(unhovered()), infoLabel, SLOT(hideToolTip())); gridLayout->addWidget(infoLabel,1,2); gridLayout->setContentsMargins(0, 0, 0, 0); diff --git a/src/ui/widgets/InformationDock.hpp b/src/ui/widgets/InformationDock.hpp index 6bd0675..09a68ad 100644 --- a/src/ui/widgets/InformationDock.hpp +++ b/src/ui/widgets/InformationDock.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/src/ui/widgets/TimeInputField.cpp b/src/ui/widgets/TimeInputField.cpp index 29e37eb..2cec05b 100644 --- a/src/ui/widgets/TimeInputField.cpp +++ b/src/ui/widgets/TimeInputField.cpp @@ -28,7 +28,9 @@ TimeInputField::TimeInputField(QString text, TimeUnit resolution, types::TraceTi this->textLabel = new QLabel(this->text, this); this->lineEdit = new QLineEdit(QString::number(this->time.count()), this); - this->lineEdit->setValidator(new QDoubleValidator(this)); + auto validator = new QDoubleValidator(this); + validator->setLocale(QLocale::English); + this->lineEdit->setValidator(validator); this->comboBox = new QComboBox(this); for (const auto &unit : TIME_UNITS) { diff --git a/src/ui/widgets/Timeline.cpp b/src/ui/widgets/Timeline.cpp index fd9ed0e..620984a 100644 --- a/src/ui/widgets/Timeline.cpp +++ b/src/ui/widgets/Timeline.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -16,28 +16,283 @@ * along with this program. If not, see . */ #include "Timeline.hpp" +#include "src/models/ViewSettings.hpp" +#include "src/ui/TimeUnit.hpp" +#include "src/ui/TraceDataProxy.hpp" +#include "src/ui/views/TimelineView.hpp" +#include "src/ui/widgets/TimelineHeader.hpp" +#include "src/ui/windows/FlamegraphPopup.hpp" #include "src/ui/ScrollSynchronizer.hpp" +#include #include +#include +#include +#include +#include +#include + + Timeline::Timeline(TraceDataProxy *data, QWidget *parent) : QWidget(parent), data(data) { + this->data->triggerUITimerStartIfPossible(); auto layout = new QGridLayout(this); - this->header = new TimelineHeader(this->data, this); - layout->addWidget(this->header, 0, 1); + // this->header = new TimelineHeader(this->data, this); + // layout->addWidget(this->header, 0, 1); this->labelList = new TimelineLabelList(this->data, this); layout->addWidget(this->labelList, 1, 0); + + connect(this->data, SIGNAL(flamegraphRequest()), this, SLOT(showFlamegraphPopup())); + + // We don't want to have the context menu for layout elements in the label region + this->labelList->setContextMenuPolicy(Qt::PreventContextMenu); + + this->prepareSlidersBoxLayouts(); + this->addSliderTicks(); + layout->addWidget(this->slidersBox, 2, 0, 1, 2); + + // Make the Box hideable via shortcut (the relevant action is located in MainWindow) + connect(this->data, &TraceDataProxy::hideSlidersBoxRequest, this, &Timeline::hideSliderBox); + // It's not enough to update the tooltips alongside slider changes, if the selection changes we have to consider new time values + connect(this->data, &TraceDataProxy::selectionChanged, this, &Timeline::updateAllTooltips); this->view = new TimelineView(this->data, this); + QBrush backgroundPattern = QBrush(QColorConstants::Svg::silver, Qt::Dense7Pattern); + this->view->setBackgroundBrush(backgroundPattern); layout->addWidget(this->view, 1, 1); - // This prevents the labelList from expanding to 50% of the width. - // Not really a satisfactory solution. - layout->setColumnStretch(0, 1); - layout->setColumnStretch(1, 9); + // We don't need more space than the max width of the contents (32+16 pixel for the +/- icons) + this->labelList->setMaximumWidth(this->labelList->getMaxLabelLength()+48); + // "MPI rank 5" -> "... rank 5" makes more sense than "MPI rank ..." + this->labelList->setTextElideMode (Qt::ElideLeft); auto scrollSyncer = new ScrollSynchronizer(this); scrollSyncer->addWidget(this->labelList); scrollSyncer->addWidget(this->view); + +} + +void Timeline::showFlamegraphPopup(){ + FlamegraphPopup* flamegraph = new FlamegraphPopup(this->data, this); + flamegraph->openFlamegraphWindow(); +} + +QHBoxLayout* Timeline::prepareSlider(QSlider* sliderObj, QString Name = ""){ + + QHBoxLayout* sliderLabelBox = new QHBoxLayout(); + + if(Name!=""){ + QLabel* sliderLabel = new QLabel(Name, this); + QFont font; + font.setPointSize(8); + sliderLabel->setFont(font); + sliderLabel->setFixedWidth(24); + sliderLabel->setFixedHeight(32); + sliderLabel->setToolTip(QString("Active threshold slider for %1").arg(this->giveElementDescr(sliderObj->objectName()))); + sliderObj->setRange(0, 1000); + sliderObj->setValue(0); + sliderObj->setFixedHeight(32); + sliderObj->setToolTip("No active threshold"); + // We don't want to rush a user to read possibly complex tooltips: 600*10^3 msec => 10 min + sliderObj->setToolTipDuration(600000); + + sliderLabelBox->addWidget(sliderLabel); + sliderLabelBox->addWidget(sliderObj); + } else { + if(this->modeLabel==nullptr)this->modeLabel = new QLabel("Mode:\nperc", this); + if(this->modeIntensitySlider==nullptr) this->modeIntensitySlider = new QSlider(Qt::Vertical, this); + connect(this->modeIntensitySlider, &QSlider::valueChanged, this, [this]() { + this->changeModeEvent(); + }); + this->modeIntensitySlider->setDisabled(true); + QFont font; + font.setPointSize(8); + this->modeLabel->setFont(font); + this->modeLabel->setToolTipDuration(600000); + sliderObj->setRange(0, 2); + sliderObj->setValue(0); + sliderObj->setToolTip("Mode control"); + this->modeIntensitySlider->setRange(0, 6); + this->modeIntensitySlider->setToolTip("Intensity control\ne.g. higher value means even slower growth in slow mode"); + this->modeLabel->setFixedWidth(this->labelList->width()-32); + + + sliderLabelBox->addWidget(sliderObj); + sliderLabelBox->addSpacing(4); + sliderLabelBox->addWidget(this->modeIntensitySlider); + sliderLabelBox->addSpacing(4); + sliderLabelBox->addWidget(this->modeLabel); + } + + return sliderLabelBox; +} + +void Timeline::addSliderTicks(){ + this->thresholdSliderOV->setTickPosition(QSlider::TicksAbove); + this->thresholdSliderOV->setTickInterval(100); + + this->thresholdSliderP2P->setTickPosition(QSlider::TicksAbove); + this->thresholdSliderP2P->setTickInterval(100); + + this->thresholdSliderREG->setTickPosition(QSlider::TicksBelow); + this->thresholdSliderREG->setTickInterval(100); + + this->thresholdSliderCCM->setTickPosition(QSlider::TicksBelow); + this->thresholdSliderCCM->setTickInterval(100); +} + +void Timeline::changeModeEvent(){ + switch(this->modeSlider->value()){ + case Mode::perc: + this->modeLabel->setText("Mode:\nperc"); + this->modeLabel->setToolTip("f(x) = x"); + this->modeIntensitySlider->setDisabled(true); + this->modeIntensitySlider->setValue(0); + break; + case Mode::slow: + this->modeLabel->setText("Mode:\nslow"); + this->modeLabel->setToolTip(QString("f(x) = ((1 + 6931669/10^(9+%1))^(x*(x/1000)*10^%1) - 1) * ((x/100)^%1/10^%1)").arg(this->modeIntensitySlider->value())); + this->modeIntensitySlider->setDisabled(false); + break; + case Mode::fast: + this->modeLabel->setText("Mode:\nfast"); + this->modeLabel->setToolTip(QString("f(x) = 1000 * (x^(%1+1))/(x^(%1+1)+10)").arg(this->modeIntensitySlider->value())); + this->modeIntensitySlider->setDisabled(false); + break; + } + if(!ViewSettings::getInstance()->getUseREGSliderForOV())this->changeOverviewEvent(); + this->changeMainviewEvent(); +} + +QString Timeline::giveElementDescr(QString compactName){ + if(compactName=="OV") return "regions/functions in overview"; + if(compactName=="REG") return "regions/functions"; + if(compactName=="P2P") return "point-to-point communications"; + if(compactName=="CCM") return "collective communications"; + return "unkown"; +} + +double Timeline::scaleSliderValue(int trueVal){ + int intensityValue = this->modeIntensitySlider->value(); + double scaledVal, base, exponent, factor; + switch(this->modeSlider->value()){ + case Mode::perc: + return (double) trueVal; + case Mode::slow: + // This is only needed because of the -1 in the final scaledVal calc, which caps the value at 999 rather than 1000 + if(trueVal==1000) { + scaledVal=trueVal; + } else { + // This growth-factor was chosen because of 1.0069...^1000 approx 1000 + base = (1 + 6931669/(pow(10, 9+intensityValue))); + exponent = trueVal * pow(10, intensityValue) * trueVal/1000.0; + factor = pow(trueVal/100.0, intensityValue)/pow(10, intensityValue); + scaledVal = (pow(base, exponent) - 1) * factor; + } + return scaledVal; + case Mode::fast: + if(trueVal==1000) { + scaledVal=trueVal; + } else { + scaledVal = 1000.0 * std::pow(trueVal, intensityValue+1) / (std::pow(trueVal, intensityValue+1) + 10); + } + return scaledVal; + } + return 0; +} + +void Timeline::changeOverviewEvent(){ + auto settings = ViewSettings::getInstance(); + settings->setActiveThresholdOV(this->scaleSliderValue(this->thresholdSliderOV->value())); + auto fullTime = this->data->getTotalRuntime().count(); + this->updateTooltip(this->thresholdSliderOV, settings->getActiveThresholdOV(), fullTime); + Q_EMIT data->refreshOverviewRequest(); +} + +void Timeline::changeMainviewEvent(){ + auto settings = ViewSettings::getInstance(); + settings->setActiveThresholdREG(this->scaleSliderValue(this->thresholdSliderREG->value())); + settings->setActiveThresholdP2P(this->scaleSliderValue(this->thresholdSliderP2P->value())); + settings->setActiveThresholdCCM(this->scaleSliderValue(this->thresholdSliderCCM->value())); + this->updateAllTooltips(); + this->view->updateView(); + if(settings->getUseREGSliderForOV()){ + this->thresholdSliderOV->setToolTip("currently not used!"); + Q_EMIT data->refreshOverviewRequest(); + } +} + +void Timeline::updateAllTooltips(){ + auto settings = ViewSettings::getInstance(); + auto fullTime = this->data->getSelection()->getDuration().count(); + // The OV-update is handled in Timeline::changeOverviewEvent + this->updateTooltip(this->thresholdSliderREG, settings->getActiveThresholdREG(), fullTime); + this->updateTooltip(this->thresholdSliderP2P, settings->getActiveThresholdP2P(), fullTime); + this->updateTooltip(this->thresholdSliderCCM, settings->getActiveThresholdCCM(), fullTime); } + +void Timeline::updateTooltip(QSlider* sliderObj, double currentScaledValue, long fullTime){ + + QString relativeToWhat = "current selection size"; + if(sliderObj->objectName()=="OV") relativeToWhat = "full trace size"; + + if(sliderObj->value()){ + QString activeFilterMsg = QString("Active threshold:\n%1 < %2 [ns] are ignored!\nwhich is %3\% of the %4 %5 [ns]").arg(this->giveElementDescr(sliderObj->objectName())).arg(fullTime*currentScaledValue/1000.0).arg(currentScaledValue/10.0).arg(relativeToWhat).arg((double)fullTime); + QString activeFilterMsgFull = QString("Active threshold:\n%1 < %4 %5 [ns] are ignored!").arg(this->giveElementDescr(sliderObj->objectName())).arg(relativeToWhat).arg((double)fullTime); + sliderObj->value() < 1000 ? sliderObj->setToolTip(activeFilterMsg) : sliderObj->setToolTip(activeFilterMsgFull); + } else { + sliderObj->setToolTip("No active threshold"); + } +} + +void Timeline::prepareSlidersBoxLayouts(){ + this->modeSlider = new QSlider(Qt::Vertical, this); + this->modeSlider->setObjectName(""); + connect(this->modeSlider, &QSlider::valueChanged, this, [this]() { + this->changeModeEvent(); + }); + + + this->thresholdSliderOV = new QSlider(Qt::Horizontal, this); + this->thresholdSliderOV->setObjectName("OV"); + connect(this->thresholdSliderOV, &QSlider::valueChanged, this, [this]() { + this->changeOverviewEvent(); + }); + + this->thresholdSliderREG = new QSlider(Qt::Horizontal, this); + this->thresholdSliderREG->setObjectName("REG"); + connect(this->thresholdSliderREG, &QSlider::valueChanged, this, [this]() { + this->changeMainviewEvent(); + }); + + this->thresholdSliderP2P = new QSlider(Qt::Horizontal, this); + this->thresholdSliderP2P->setObjectName("P2P"); + connect(this->thresholdSliderP2P, &QSlider::valueChanged, this, [this]() { + this->changeMainviewEvent(); + }); + this->thresholdSliderCCM = new QSlider(Qt::Horizontal, this); + this->thresholdSliderCCM->setObjectName("CCM"); + connect(this->thresholdSliderCCM, &QSlider::valueChanged, this, [this]() { + this->changeMainviewEvent(); + }); + + this->slidersBox = new QGroupBox(); + auto slidersLayoutREG = new QVBoxLayout(); + slidersLayoutREG->addLayout(this->prepareSlider(this->thresholdSliderOV, this->thresholdSliderOV->objectName())); + slidersLayoutREG->addLayout(this->prepareSlider(this->thresholdSliderREG, this->thresholdSliderREG->objectName())); + auto slidersLayoutCOM = new QVBoxLayout(); + slidersLayoutCOM->addLayout(this->prepareSlider(this->thresholdSliderP2P, this->thresholdSliderP2P->objectName())); + slidersLayoutCOM->addLayout(this->prepareSlider(this->thresholdSliderCCM, this->thresholdSliderCCM->objectName())); + QHBoxLayout* slidersLayout = new QHBoxLayout(); + slidersLayout->addLayout(this->prepareSlider(this->modeSlider, this->modeSlider->objectName())); + slidersLayout->addLayout(slidersLayoutREG); + slidersLayout->addLayout(slidersLayoutCOM); + this->slidersBox->setLayout(slidersLayout); + this->slidersBox->setMaximumHeight(86); +} + +void Timeline::hideSliderBox(){ + this->slidersBox->isHidden() ? this->slidersBox->setHidden(false) : this->slidersBox->setHidden(true); +} \ No newline at end of file diff --git a/src/ui/widgets/Timeline.hpp b/src/ui/widgets/Timeline.hpp index 414b54f..f98710c 100644 --- a/src/ui/widgets/Timeline.hpp +++ b/src/ui/widgets/Timeline.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,6 +20,10 @@ #include +#include +#include +#include + #include "TimelineHeader.hpp" #include "TimelineLabelList.hpp" @@ -44,11 +48,37 @@ class Timeline : public QWidget { */ explicit Timeline(TraceDataProxy *data, QWidget *parent = nullptr); +public Q_SLOTS: + void showFlamegraphPopup(); + void changeOverviewEvent(); + void changeMainviewEvent(); + private: // widgets - TimelineHeader *header = nullptr; + // TimelineHeader *header = nullptr; TimelineLabelList *labelList = nullptr; TimelineView *view = nullptr; + enum Mode { perc, slow, fast }; + QLabel *modeLabel = nullptr; + QSlider *modeSlider = nullptr; + QSlider *modeIntensitySlider = nullptr; + QSlider *thresholdSliderOV = nullptr; + QSlider *thresholdSliderREG = nullptr; + QSlider *thresholdSliderP2P = nullptr; + QSlider *thresholdSliderCCM = nullptr; + QGroupBox *slidersBox = nullptr; + +private: // methods + QHBoxLayout* prepareSlider(QSlider* thresholdSlider, QString Name); + void prepareSlidersBoxLayouts(); + void addSliderTicks(); + void changeModeEvent(); + void updateAllTooltips(); + QString giveElementDescr(QString compactName); + void updateTooltip(QSlider* sliderObj, double currentScaledValue, long fullTime); + double scaleSliderValue(int trueVal); + void hideSliderBox(); + private: // data TraceDataProxy *data = nullptr; }; diff --git a/src/ui/widgets/TimelineHeader.cpp b/src/ui/widgets/TimelineHeader.cpp index 729c6c7..913a5ba 100644 --- a/src/ui/widgets/TimelineHeader.cpp +++ b/src/ui/widgets/TimelineHeader.cpp @@ -28,7 +28,8 @@ TimelineHeader::TimelineHeader(TraceDataProxy *data, QWidget *parent) : QWidget( this->updateView(); // @formatter:off - connect(this->data, SIGNAL(selectionChanged(types::TraceTime,types::TraceTime)), this, SLOT(updateView())); + // Attention: this connect causes redundant rendering of the scenery for TimelineView + // connect(this->data, SIGNAL(selectionChanged(types::TraceTime,types::TraceTime)), this, SLOT(updateView())); // @formatter:on } diff --git a/src/ui/widgets/TimelineLabelList.cpp b/src/ui/widgets/TimelineLabelList.cpp index 16d4c31..0ce61fb 100644 --- a/src/ui/widgets/TimelineLabelList.cpp +++ b/src/ui/widgets/TimelineLabelList.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -16,28 +16,143 @@ * along with this program. If not, see . */ #include "TimelineLabelList.hpp" +#include "src/models/Trace.hpp" +#include "src/models/ViewSettings.hpp" +#include "src/ui/TraceDataProxy.hpp" #include #include #include +#include +#include +#include + +#include TimelineLabelList::TimelineLabelList(TraceDataProxy *data, QWidget *parent) : QListWidget(parent), data(data) { this->setFrameShape(QFrame::NoFrame); this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + //this->setSelectionMode(QAbstractItemView::NoSelection); + + this->menu = new QMenu(this); + this->menu->setStyleSheet("QMenu { background-color: rgba(250, 250, 250, 180); border: 2px solid rgba(170, 170, 170, 120); } QMenu::item:selected { background-color: rgba(250, 250, 250, 230); color: black; } "); + this->labelAction1 = this->menu->addAction("highlight process"); + this->labelAction1->setDisabled(true); + this->labelAction2 = this->menu->addAction("toggle arrows (P2P)"); + this->labelAction3 = this->menu->addAction("show flamegraph"); + connect(this->labelAction1, &QAction::triggered, this, &TimelineLabelList::highlightPreparation); + connect(this->labelAction2, &QAction::triggered, this, &TimelineLabelList::togglePointToPointPreparation); + connect(this->labelAction3, &QAction::triggered, this, &TimelineLabelList::flamegraphPreparation); + connect(this->data, &TraceDataProxy::verticalZoomChanged, this, &TimelineLabelList::resizeLabels); + + // This prevents asynchronous scrolling relative to TimelineView + this->setVerticalScrollMode(ScrollPerPixel); this->setStyleSheet("background: transparent"); - setViewportMargins(0, 20, 0, 0); + // Why top=20? <= top in TimelineView.cpp + //setViewportMargins(0, 20, 0, 0); + // Alternative with a bufferzone we can scroll into + auto extraSpaceTop = new QListWidgetItem(this); + // We dont want the extra space to be selectable etc. + extraSpaceTop->setFlags(Qt::NoItemFlags); + extraSpaceTop->setSizeHint(QSize(0, 20)); + this->addItem(extraSpaceTop); + - for (const auto &ranks: this->data->getSelection()->getSlots()) { - const auto &rankName = ranks.first->name().str(); + for (const auto &rank: this->data->getSelection()->getSlots()) { + const QString &rankName = QString::fromStdString(rank.first->name().str()); + auto rankThreadMap = ViewSettings::getInstance()->getRankThreadMap(); + auto rankAdrMap = ViewSettings::getInstance()->getRankAdrMap(); auto item = new QListWidgetItem(this); - item->setText(QString::fromStdString(rankName)); - item->setSizeHint(QSize(0, 30 /* TODO ROW_HEIGHT */)); + + if(maxLabelLength < fontMetrics().boundingRect(rankName).width()) maxLabelLength=fontMetrics().boundingRect(rankName).width(); + + // Multithreading check + // If we haven't seen this rank before... + if(rankThreadMap->count(rank.first->ref().get())==0){ + std::map>> threadMap{}; + // We use that to figure out the thread position <=> threadNumber + std::map threadMap_{}; + for (const auto &slot_: rank.second) { + auto threadRef = std::to_string(slot_->location->ref().get()); + auto threadName = slot_->location->name().str(); + // If we haven't seen this thread before... + if(!threadMap_.count(threadRef)){ + threadMap_.insert({threadName, threadRef}); + } + } + //std::make_pair(threadRef, bool[3]{false, false, false}) + // Whats their position? (threadNumber for main thread => 1) + auto threadNumber = threadMap.size(); + for (auto &threadItem: threadMap_) { + threadNumber++; + // Settings vector for individual threads = "highlighted?" - "toggled P2P?" + std::vector boolVector {false, false}; + std::pair> entry {threadNumber, boolVector}; + threadMap.insert({threadItem.second, entry}); + } + rankThreadMap->insert({rank.first->ref().get(), std::make_pair(false, threadMap)}); + rankAdrMap->insert({rank.first->ref().get(), rank.first}); + } + + item->setText(rankName); + item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable); + item->setData(Qt::UserRole, rank.first->ref().get()); + item->setToolTip(QString::fromStdString("node: "+rank.first->parent().name().str())); item->setTextAlignment(Qt::AlignCenter); + this->widgetPointerList.push_front(item); + + // This handles the +/- icon, background-brush and size + this->adjustIcon(item, rank.first->ref().get()); + this->addItem(item); } + auto extraSpaceBottom = new QListWidgetItem(this); + // We dont want the extra space to be selectable etc. + extraSpaceBottom->setFlags(Qt::NoItemFlags); + extraSpaceBottom->setSizeHint(QSize(0, 20)); + this->addItem(extraSpaceBottom); } -void TimelineLabelList::mousePressEvent(QMouseEvent *) { +void TimelineLabelList::mousePressEvent(QMouseEvent *event) { + // First: determine where the click happend + auto *item = this->itemAt(event->pos()); + + if (item != nullptr) { + QString rankName = item->text(); + // Filter: we don't want any click behavior for padding labels (extraSpaceTop, extraSpaceBottom), this is how we spot them + if(rankName.isEmpty()) return; + } + else { + return; + } + + // We need to know the associated rank + int rankRef = item->data(Qt::UserRole).toInt(); + auto settings = ViewSettings::getInstance(); + + switch (event->button()) { + case Qt::LeftButton: { + // Filter: e can't expand thre multithreading view for ranks without multithreading, this is how we spot them + if(item->background().color()==QColorConstants::Svg::silver) return; + // We flip the multithreading-view bool via XOR + settings->getRankThreadMap()->at(rankRef).first ^= true; + // This handles the +/- icon, background-brush and size + Q_EMIT this->data->refreshButtonPressed(); + this->adjustIcon(item, rankRef); + //Q_EMIT this->data->labelInteractionTrigger(); + + }break; + case Qt::RightButton: { + item->setSelected(true); + this->labelAction2->setData(rankRef); + this->labelAction3->setData(rankRef); + //this->menu->exec(event->globalPos()); + this->menu->exec(event->globalPosition().toPoint()); + }break; + default: { + return; + } + } return; } @@ -48,3 +163,79 @@ void TimelineLabelList::mouseReleaseEvent(QMouseEvent *) { void TimelineLabelList::mouseMoveEvent(QMouseEvent *) { return; } + +int TimelineLabelList::getMaxLabelLength() { + return maxLabelLength; +} + +void TimelineLabelList::highlightPreparation(){ + //qInfo() << "highlight ..."; +} + +void TimelineLabelList::togglePointToPointPreparation(){ + + QAction *action = qobject_cast(sender()); + if (!action) return; + + int rankRef = action->data().toInt(); + auto settings = ViewSettings::getInstance(); + + // We flip the toggle status for all threads that are associated with this rank + for (auto &entry : settings->getRankThreadMap()->at(rankRef).second){ + entry.second.second.at(1).flip(); + } + + for (auto labelItem : this->widgetPointerList){ + // We should switch the textcolor from grey to black or vice versa in order to indicate the change + if(labelItem->data(Qt::UserRole).toInt()==rankRef) labelItem->foreground()==Qt::gray ? labelItem->setForeground(Qt::black) : labelItem->setForeground(Qt::gray); + } + + Q_EMIT this->data->refreshButtonPressed(); +} + +void TimelineLabelList::flamegraphPreparation(){ + + QAction *action = qobject_cast(sender()); + if (!action) return; + + int rankRef = action->data().toInt(); + auto settings = ViewSettings::getInstance(); + settings->setFlamegraphRankRef(rankRef); + + Q_EMIT this->data->flamegraphRequest(); +} + +void TimelineLabelList::resizeLabels() { + const QSize newSize(0,ViewSettings::getInstance()->getRowHeight()); + for(auto labelEntry : this->widgetPointerList){ + labelEntry->setSizeHint(newSize); + } +} + +void TimelineLabelList::adjustIcon(QListWidgetItem * rankLabel, int rankKey) { + auto rankThreadMap = ViewSettings::getInstance()->getRankThreadMap(); + auto plusIcon = ViewSettings::getInstance()->getIcon("plus"); + auto plusIconGrey = ViewSettings::getInstance()->getIcon("plus_grey"); + auto minusIcon = ViewSettings::getInstance()->getIcon("minus"); + + auto iconToggleStatus = rankThreadMap->at(rankKey).first; + auto rankSizeOffset = rankThreadMap->at(rankKey).second.size()-1; + auto currentRowHeight = ViewSettings::getInstance()->getRowHeight(); + + QBrush backgroundPatternOpen = QBrush(QColorConstants::Svg::lightsteelblue, Qt::Dense6Pattern); + QBrush backgroundPatternClosed = QBrush(QColorConstants::Svg::lightsteelblue, Qt::Dense4Pattern); + QBrush backgroundPatternNoMultithreading = QBrush(QColorConstants::Svg::silver, Qt::Dense4Pattern); + + // Standard procedure + rankLabel->setSizeHint(QSize(0, currentRowHeight+(rankSizeOffset*currentRowHeight*iconToggleStatus))); + rankLabel->setTextAlignment(Qt::AlignCenter); + + // If the amount of threads (<=> rankSizeOffset+1) < 2 => non-expandable <=> grey icon + if(rankSizeOffset<1){ + rankLabel->setIcon(*plusIconGrey); + rankLabel->setBackground(backgroundPatternNoMultithreading); + } + else{ + iconToggleStatus ? (rankLabel->setIcon(*minusIcon), rankLabel->setBackground(backgroundPatternOpen)) : (rankLabel->setIcon(*plusIcon), rankLabel->setBackground(backgroundPatternClosed)); + } +} \ No newline at end of file diff --git a/src/ui/widgets/TimelineLabelList.hpp b/src/ui/widgets/TimelineLabelList.hpp index 766b8da..550ac20 100644 --- a/src/ui/widgets/TimelineLabelList.hpp +++ b/src/ui/widgets/TimelineLabelList.hpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,6 +21,7 @@ #include +#include "src/models/ViewSettings.hpp" #include "src/ui/TraceDataProxy.hpp" /** @@ -40,6 +41,8 @@ class TimelineLabelList : public QListWidget { */ TimelineLabelList(TraceDataProxy *data, QWidget *parent = nullptr); + int getMaxLabelLength(); + protected: /* * NOTE: we override this function to prevent the items from being clicked/activated. @@ -61,6 +64,18 @@ class TimelineLabelList : public QListWidget { private: TraceDataProxy *data = nullptr; + QListWidget* widgetList; + QList widgetPointerList; + QMenu *menu; + int maxLabelLength = 0; + QAction *labelAction1; + void highlightPreparation(); + QAction *labelAction2; + void togglePointToPointPreparation(); + QAction *labelAction3; + void flamegraphPreparation(); + void resizeLabels(); + void adjustIcon(QListWidgetItem * rankLabel, int rankKey); }; diff --git a/src/ui/widgets/TraceOverviewDock.cpp b/src/ui/widgets/TraceOverviewDock.cpp index 4e2c58d..98c06eb 100644 --- a/src/ui/widgets/TraceOverviewDock.cpp +++ b/src/ui/widgets/TraceOverviewDock.cpp @@ -27,6 +27,8 @@ TraceOverviewDock::TraceOverviewDock(TraceDataProxy *data, QWidget *parent) : QD connect(data, SIGNAL(selectionChanged(types::TraceTime,types::TraceTime)), timelineView, SLOT(setSelectionWindow(types::TraceTime,types::TraceTime))); connect(timelineView, SIGNAL(windowSelectionChanged(types::TraceTime,types::TraceTime)), data, SLOT(setSelection(types::TraceTime,types::TraceTime))); - connect(data, SIGNAL(colorChanged()), timelineView, SLOT(updateView())); + //connect(data, SIGNAL(colorChanged()), timelineView, SLOT(updateView())); connect(data, SIGNAL(colorChanged()), timelineView, SLOT(updateUITrace())); + connect(data, SIGNAL(refreshOverviewRequest()), timelineView, SLOT(updateView())); + connect(data, SIGNAL(refreshButtonPressed()), timelineView, SLOT(updateUITrace())); } diff --git a/src/ui/widgets/infostrategies/InformationDockElementBaseStrategy.cpp b/src/ui/widgets/infostrategies/InformationDockElementBaseStrategy.cpp index 1db8f62..77bb5bd 100644 --- a/src/ui/widgets/infostrategies/InformationDockElementBaseStrategy.cpp +++ b/src/ui/widgets/infostrategies/InformationDockElementBaseStrategy.cpp @@ -51,7 +51,7 @@ InformationDockElementBaseStrategy::update(QFormLayout *layout, TimedElement if (t) { updateView(layout, t); } - + return t; } diff --git a/src/ui/widgets/mpianalysis/LogicalClock.cpp b/src/ui/widgets/mpianalysis/LogicalClock.cpp new file mode 100644 index 0000000..1163ca2 --- /dev/null +++ b/src/ui/widgets/mpianalysis/LogicalClock.cpp @@ -0,0 +1,401 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include + +#include "LogicalClock.hpp" +#include "src/ui/Constants.hpp" +#include "src/ui/views/CommunicationIndicator.hpp" +#include "src/ui/views/NodeIndicator.hpp" + +//DEBUG INCLUDE +#include +constexpr int X_OFFSET = 50; +constexpr int Y_OFFSET = 80; +constexpr int RADIUS = 15; + +const QColor SEND_COLOR("#4A69A6"); +const QColor RECV_COLOR("#508B52"); +const QColor COLLECTIVES_COLOR("#C32727"); +const QColor OTHERS_COLOR("#A9A7A7"); + +LogicalClock::LogicalClock(TraceDataProxy *data, std::map> nodes, QWidget *parent): QGraphicsView(parent), + data(data), nodes(nodes){ + + auto scene = new QGraphicsScene(); + this->setAlignment(Qt::AlignTop | Qt::AlignLeft); + this->setAutoFillBackground(false); + this->setStyleSheet("background: transparent"); + this->setScene(scene); + this->populateScene(scene); + +} + + +// Index aliases for accessing elements in pendingCollectives tuples: +// IDX_MAX_NODE_COUNT: Represents the largest node count among members, used for X-axis offset. +// IDX_START_Y: Index for the starting Y-coordinate. +// IDX_END_Y: Index for the ending Y-coordinate. +// IDX_INITIAL_LOCATION: Represents the location of the first occurrence of a specific collective communication. +// IDX_FINISHED_MEMBERS: Used to avoid redundant iterations. + +constexpr size_t IDX_MAX_NODE_COUNT = 0; +constexpr size_t IDX_START_Y = 1; +constexpr size_t IDX_END_Y = 2; +constexpr size_t IDX_INITIAL_LOCATION = 3; +constexpr size_t IDX_FINISHED_MEMBERS = 4; + +std::map> DEBUG_COUNTER; + +int DEBUG_CALL_COUNTER = 0; + +void LogicalClock::populateScene(QGraphicsScene* scene) { + + // Build nodes_ map with finishing state for each node. + std::map>> nodes_; + std::pair matchingNodes; + + for (auto &item : nodes) { + for(auto node: item.second){ + auto location = node->getSlot()->location->ref(); + if(nodes_.find(location) == nodes_.end()) nodes_[location] = std::vector>(); + nodes_[location].push_back(std::make_pair(node, false)); + } + } + + // Map contains x-axis offset(first) and vector index(second) by location + std::map> nodeCountMap; + // Tupel: (x, y, count) + std::map> pendingEdges; + std::map>> pendingCollectives; + + drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene); + + for(size_t i = 0; i < nodeCountMap.size(); ++i){ + QGraphicsLineItem* line = scene->addLine(0, i * Y_OFFSET, 1080, i * Y_OFFSET); + line->setZValue(-1); + + QString label = QString("Rank: %1").arg(i); + QGraphicsTextItem* textItem = new QGraphicsTextItem(label); + textItem->setPos(-textItem->boundingRect().width() - 10, i * Y_OFFSET - textItem->boundingRect().height() / 2); + textItem->setZValue(-1); + scene->addItem(textItem); + } + + for(const auto& collectivCommunication: pendingCollectives){ + if(!(collectivCommunication.first->getKind() == CommunicationKind::Synchronizing)) continue; + int x = (std::get(collectivCommunication.second) * X_OFFSET); + int yStart = std::get(collectivCommunication.second); + int yEnd = std::get(collectivCommunication.second); + + QGraphicsLineItem* line = scene->addLine(x, yStart, x, yEnd); + line->setPen(QPen(Qt::red)); + } + + // for(const auto& item: DEBUG_COUNTER){ + // std::cout << "Location: " << item.first + // << " P2P: " << item.second.first + // << " Collectives: " << item.second.second << std::endl; + // } +} + +void LogicalClock::drawNodes(std::map>>& nodes_, + std::map>& nodeCountMap, + std::map>& pendingEdges, + std::map>>& pendingCollectives, + QGraphicsScene* scene, + uint64_t location_, + std::pair* matchingNodes) + { + DEBUG_CALL_COUNTER++; + auto onTimedElementSelected = [this](TimedElement *element) { this->data->setTimeElementSelection(element); }; + + // Begin Iteration at specific location, default = 0 + auto item = nodes_.lower_bound(location_); + for(; item!= nodes_.end(); ++item){ + auto location = item->first; + if(nodeCountMap.find(location)==nodeCountMap.end()){ + nodeCountMap[location].first = 1; + nodeCountMap[location].second = 0; + } + int& count = nodeCountMap[location].first; + + // Continue node vector iteration at last position + for(size_t j = nodeCountMap[location].second; j < item->second.size(); ++j){ + auto& node = item->second[j].first; + auto nodeFinishState = item->second[j].second; + if(nodeFinishState) continue; + QColor color = OTHERS_COLOR; + + auto region = QString::fromStdString(node->getRegionName().str()); + auto DEBUG_REGION = region.toStdString(); + if(region.contains("Init") || region.contains("Comm") || region.contains("Group") || region.contains("Finalize")) { + nodeFinishState = true; + nodeCountMap[location].second++; + continue; //workaround + } + + if ((region.contains("send", Qt::CaseInsensitive) || region.contains("recv", Qt::CaseInsensitive)) && !(node->hasCommunication())) color = Qt::red; + int y = (location * Y_OFFSET) - RADIUS; + int x = (count * X_OFFSET) - RADIUS; + + + // Node is P2P communication + if(node->hasCommunication()){ + /* DEBUG INFO DELETE + auto commStartTime = std::chrono::duration(node->getOwnEvent()->getStartTime()).count(); + auto commEndTime = std::chrono::duration(node->getOwnEvent()->getEndTime()).count(); + auto slotStartTime = std::chrono::duration(node->getSlot()->getStartTime()).count(); + auto slotEndTime = std::chrono::duration(node->getSlot()->getEndTime()).count(); + + std::cout << location << " " << node->getRegionName().str() << " "; + std::cout << std::fixed << std::setprecision(6) << slotStartTime << " "; + std::cout << std::fixed << std::setprecision(6) << slotEndTime << " "; + std::cout << std::fixed << std::setprecision(6) << commStartTime << " "; + std::cout << std::fixed << std::setprecision(6) << commEndTime << std::endl; + */ + + // Set node color + if(region.contains("send", Qt::CaseInsensitive)) color = SEND_COLOR; + else color = RECV_COLOR; + + // Preparing offset for node + uint64_t connectedNodeRank = node->getConnectedCommunicationRank(); + + if(nodeCountMap.find(connectedNodeRank)==nodeCountMap.end()){ + nodeCountMap[connectedNodeRank].first = 1; + nodeCountMap[connectedNodeRank].second = 0; + } + + if(pendingEdges.find(node->getCommunication()) == pendingEdges.end()){ + // Blocking communication needs a specific x-axis-offset + if(node->getCommunicationKind() & CommunicationKind::BlockingPointToPoint) { + // node define offset because is start event + if(node->getOwnEvent() == node->getCommunication()->getStartEvent()) { + // nodeCountMap[connectedNodeRank].first = std::max(nodeCountMap[connectedNodeRank].first, (count+1)); + pendingEdges[node->getCommunication()] = std::make_tuple(x, y, std::max(nodeCountMap[connectedNodeRank].first, (count+1))); + } + // Node has to wait for offset from connected node + else{ + if(!node->getConnectedNodes().empty()){ + auto matchingNodes = std::make_pair(node, node->getConnectedNodes()[connectedNodeRank][0]); + drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, connectedNodeRank, &matchingNodes); + } + //TODO WARNUNG PRINTEN + else drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, connectedNodeRank); + } + if(nodeFinishState) continue; + + // overwrite x, maybe count has changed! + x = (count * X_OFFSET) - RADIUS; + } + + if(pendingEdges.find(node->getCommunication()) == pendingEdges.end()) pendingEdges[node->getCommunication()] = std::make_tuple(x, y, std::max(nodeCountMap[connectedNodeRank].first, (count+1))); + } + + // Preparing coordinates for edges + // if(node->getOwnEvent() == node->getCommunication()->getEndEvent() && !(nodeFinishState)){ + + // Calculate Offset for Blocking-Endevent + if(node->getCommunicationKind() & CommunicationKind::BlockingPointToPoint) { + if(node->getOwnEvent() == node->getCommunication()->getEndEvent()) { + count = std::max(count, std::get<2>(pendingEdges[node->getCommunication()])); + } + } + + uint64_t pendingY = std::get<1>(pendingEdges[node->getCommunication()]); + uint64_t pendingLocation = (pendingY + RADIUS)/Y_OFFSET; + if(pendingLocation != location || connectedNodeRank == location){ + x = (nodeCountMap[location].first * X_OFFSET) - RADIUS; + + auto nonConstCommunication = const_cast(node->getCommunication()); + qreal fromX = x + RADIUS; + qreal fromY = y + RADIUS; + + qreal toX = std::get<0>(pendingEdges[node->getCommunication()]) + RADIUS; + qreal toY = std::get<1>(pendingEdges[node->getCommunication()]) + RADIUS; + + if(!region.contains("send", Qt::CaseInsensitive)){ + fromX = toX; + fromY = toY; + + toX = x + RADIUS; + toY = y + RADIUS; + } + + auto arrow = new CommunicationIndicator(nonConstCommunication, fromX, fromY, toX, toY); + arrow->setZValue(layers::Z_LAYER_P2P_COMMUNICATIONS); + arrow->setPen(QPen(Qt::black)); + arrow->setOnSelected(onTimedElementSelected); + scene->addItem(arrow); + } + + if(matchingNodes != nullptr){ + auto initialNodeRegion = QString::fromStdString(matchingNodes->first->getRegionName().str()); + if(initialNodeRegion.contains("wait",Qt::CaseInsensitive)) { + auto initialNodeLocation = matchingNodes->first->getLocation(); + nodeCountMap[initialNodeLocation].first = std::max(count+1, nodeCountMap[initialNodeLocation].first); + } + } + } + + + // Node is collective communication + else if(node->hasCollectiveCommunication()){ + color = COLLECTIVES_COLOR; + const auto collectiveCommunication = node->getCollectiveCommunication(); + int lineLength = 2*RADIUS; + int yStart = y; + int yEnd = yStart + lineLength; + + if(pendingCollectives.find(collectiveCommunication) == pendingCollectives.end()) pendingCollectives[collectiveCommunication] = std::make_tuple(count, yStart, yEnd, location, std::set()); + std::set& membersSet = std::get(pendingCollectives[collectiveCommunication]); + + std::get(pendingCollectives[collectiveCommunication]) = std::max(count, std::get(pendingCollectives[collectiveCommunication])); + std::get(pendingCollectives[collectiveCommunication]) = std::min(yStart, std::get(pendingCollectives[collectiveCommunication])); + std::get(pendingCollectives[collectiveCommunication]) = std::max(yEnd, std::get(pendingCollectives[collectiveCommunication])); + + membersSet.insert(location); + + // auto collectiveType = collectiveCommunication->getOperation(); + // if(collectiveType == otf2::collective_type::reduce){ + // std::cout << "DEBUG HERE" << std::endl; + // } + + bool isBlockingRoot = ((!region.contains("MPI_I")) && location == collectiveCommunication->getRoot()); + if(node->getCommunicationKind()==CommunicationKind::Synchronizing || isBlockingRoot ){ + if(location_ == std::get(pendingCollectives[node->getCollectiveCommunication()]) || isBlockingRoot){ + auto members = collectiveCommunication->getMembers(); + + // std::sort(members.begin(), members.end(), + // [](const CollectiveCommunicationEvent::Member* a, const CollectiveCommunicationEvent::Member* b) { + // return a->getStart() < b->getStart(); + // }); + + for(auto &member: members){ + auto memberLocation = member->getLocation()->ref(); + if(membersSet.find(memberLocation) == membersSet.end()){ + if(!node->getConnectedNodes().empty()){ + auto matchingNodes = std::make_pair(node, node->getConnectedNodes()[memberLocation][0]); + drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, memberLocation, &matchingNodes); + } else drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, memberLocation); + } + } + } + } + + std::get(pendingCollectives[collectiveCommunication]) = std::get(pendingCollectives[collectiveCommunication]); + std::get(pendingCollectives[collectiveCommunication]) = std::min(yStart, std::get(pendingCollectives[collectiveCommunication])); + std::get(pendingCollectives[collectiveCommunication]) = std::max(yEnd, std::get(pendingCollectives[collectiveCommunication])); + + count = std::get(pendingCollectives[node->getCollectiveCommunication()]); + x = (count * X_OFFSET) - RADIUS; + count++; + + } + + // else if(region.contains("wait", Qt::CaseInsensitive)){ + // for(auto waitingNode : node->getConnectedNodes()[location]){ + // auto waitingNodeRegion_ = waitingNode->getRegionName().str(); + // std::cout << "[" << waitingNode->getLocation() << "] "<< waitingNodeRegion_ << std::endl; + // // Wait refers to P2P communication + // if(waitingNode->hasCommunication()){ + // auto connectedNodeRank = waitingNode->getConnectedCommunicationRank(); + // auto connectedNode = waitingNode->getConnectedNodes()[connectedNodeRank][0]; + + // // if(waitingNode->getOwnEvent()->getEndTime() > waitingNode->getConnectedEvent()->getEndTime()) { + // // if(waitingNode->getOwnEvent() == waitingNode->getCommunication()->getStartEvent()){ + // // nodeCountMap[connectedNodeRank].first = std::max(nodeCountMap[connectedNodeRank].first, (count+1)); + // // } else{ + // // auto matchingNodes = std::make_pair(node, connectedNode); + // // drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, connectedNodeRank, &matchingNodes); + // // } + + // if(waitingNode->getOwnEvent() == waitingNode->getCommunication()->getStartEvent()) { + // auto matchingNodes = std::make_pair(node, connectedNode); + // drawNodes(nodes_, nodeCountMap, pendingEdges, pendingCollectives, scene, connectedNodeRank, &matchingNodes); + // } + + // count = std::max(count,nodeCountMap[location].first); + // // overwrite x, maybe count has changed! + // x = (count * X_OFFSET) - RADIUS; + // } + // } + + // } + + if(nodeFinishState) continue; + + auto ellipseItem = new NodeIndicator(node->getSlot(), x, y, 2*RADIUS, 2*RADIUS); + //ellipseItem->setOnDoubleClick(onTimedElementDoubleClicked); + ellipseItem->setOnSelected(onTimedElementSelected); + + // QBrush brush(node->getColor()); + QBrush brush(color); + ellipseItem->setBrush(brush); + + QString hoverText = region; + ellipseItem->setToolTip(hoverText); + ellipseItem->setAcceptHoverEvents(true); + + if(node->hasCommunication() && (node->getCommunicationKind() & CommunicationKind::BlockingPointToPoint)){ + QPen pen(Qt::red); + // pen.setWidth(2); + ellipseItem->setPen(pen); + } + + // if(node->hasCommunication() && (node->getCommunicationKind() & CommunicationKind::NonBlockingPointToPoint)){ + // QGraphicsEllipseItem* coverPattern = new QGraphicsEllipseItem(x, y, 2*RADIUS, 2*RADIUS); + // QPixmap patternPixmap(16, 16); + // patternPixmap.fill(color); + + // QBrush patternBrush(patternPixmap); + // patternBrush.setStyle(Qt::DiagCrossPattern); + // coverPattern->setBrush(patternBrush); + // scene->addItem(coverPattern); + // coverPattern->setZValue(5); + // } + + nodeFinishState = true; + nodeCountMap[location].second++; + if(node->hasCollectiveCommunication()){ + if(!(node->getCommunicationKind()==CommunicationKind::Synchronizing)) scene->addItem(ellipseItem); + + if(matchingNodes !=nullptr){ + auto initialLocation = std::get(pendingCollectives[node->getCollectiveCommunication()]); + if(matchingNodes->first->hasCollectiveCommunication()){ + if(node == matchingNodes->second && initialLocation != location_) return; + } + } + + }else{ + if(matchingNodes !=nullptr){ + scene->addItem(ellipseItem); + + if(node == matchingNodes->second && location_ != 0){ + count++; + return; + } + }else scene->addItem(ellipseItem); + count++; + } + } + } + +} \ No newline at end of file diff --git a/src/ui/widgets/mpianalysis/LogicalClock.hpp b/src/ui/widgets/mpianalysis/LogicalClock.hpp new file mode 100644 index 0000000..8016ac6 --- /dev/null +++ b/src/ui/widgets/mpianalysis/LogicalClock.hpp @@ -0,0 +1,63 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_LOGICALCLOCK_HPP +#define MOTIV_LOGICALCLOCK_HPP + +#include +#include +#include +#include + + + +#include "src/ui/TraceDataProxy.hpp" +#include "src/models/mpianalysis/Node.hpp" + + +class LogicalClock : public QGraphicsView { + Q_OBJECT + +public: + /** + * @brief Creates a new instance of the LogicalClock class + * + * @param data The data proxy to obtain the current selection of the trace and to connect to change events + * @param nodes A map of node vectors indexed by location + * @param parent The parent QWidget + */ + explicit LogicalClock(TraceDataProxy *data , std::map> nodes, QWidget *parent = nullptr); + + +private: //methods + void populateScene(QGraphicsScene *element); + void drawNodes( std::map>>& nodes_, + std::map>& nodeCountMap, + std::map>& pendingEdges, + std::map>>& pendingCollectives, + QGraphicsScene* scene, + uint64_t location_ = 0, + std::pair* matchingNodes = nullptr + ); + +private: // data + TraceDataProxy *data = nullptr; + std::map> nodes; +}; + +#endif //MOTIV_LOGICALCLOCK_HPP \ No newline at end of file diff --git a/src/ui/windows/FilterPopup.cpp b/src/ui/windows/FilterPopup.cpp index 191727e..c64b06b 100644 --- a/src/ui/windows/FilterPopup.cpp +++ b/src/ui/windows/FilterPopup.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -35,15 +35,83 @@ FilterPopup::FilterPopup(const Filter &filter, QWidget *parent, const Qt::Window plainSlotKindCheckBox = new QCheckBox(tr("Show &plain function calls")); plainSlotKindCheckBox->setChecked(filter_.getSlotKinds() & SlotKind::Plain); - auto vbox = new QVBoxLayout(); - vbox->addWidget(mpiSlotKindCheckBox); - vbox->addWidget(openMpSlotKindCheckBox); - vbox->addWidget(plainSlotKindCheckBox); + // Show checkboxes for different MPI-Communication kinds + auto pointToPointCommunicationKindsGroupBox = new QGroupBox(tr("Point to Point Communication")); + pointToPointCheckBox = new QCheckBox(tr("Show &point to point communication")); + pointToPointCheckBox->setChecked((filter_.getCommunicationKinds() & CommunicationKind::PointToPoint) == CommunicationKind::PointToPoint); - vbox->addStretch(1); - slotKindsGroupBox->setLayout(vbox); + blockingPointToPointCheckBox = new QCheckBox(tr("Show &blocking point to point communication")); + blockingPointToPointCheckBox->setDisabled(pointToPointCheckBox->isChecked()); + blockingPointToPointCheckBox->setChecked((filter_.getCommunicationKinds() & CommunicationKind::BlockingPointToPoint) == CommunicationKind::BlockingPointToPoint); + + nonBlockingPointToPointCheckBox = new QCheckBox(tr("Show &non-blocking point to point communication")); + nonBlockingPointToPointCheckBox->setDisabled(pointToPointCheckBox->isChecked()); + nonBlockingPointToPointCheckBox->setChecked((filter_.getCommunicationKinds() & CommunicationKind::NonBlockingPointToPoint) == CommunicationKind::NonBlockingPointToPoint); + + connect(pointToPointCheckBox, &QCheckBox::toggled, [this] { + if(pointToPointCheckBox->isChecked()){ + blockingPointToPointCheckBox->setChecked(pointToPointCheckBox->isChecked()); + blockingPointToPointCheckBox->setDisabled(pointToPointCheckBox->isChecked()); + + nonBlockingPointToPointCheckBox->setChecked(pointToPointCheckBox->isChecked()); + nonBlockingPointToPointCheckBox->setDisabled(pointToPointCheckBox->isChecked()); + + }else{ + blockingPointToPointCheckBox->setDisabled(false); + nonBlockingPointToPointCheckBox->setDisabled(false); + } + }); + + + auto collectivCommunicationKindsGroupBox = new QGroupBox(tr("Collectiv Communication")); + collectiveCheckBox = new QCheckBox(tr("Show &collective communication")); + collectiveCheckBox->setChecked((filter_.getCommunicationKinds() & CommunicationKind::Collective)==CommunicationKind::Collective); + + synchoCheckBox = new QCheckBox(tr("Show &synchronizing communication")); + synchoCheckBox->setDisabled(collectiveCheckBox->isChecked()); + synchoCheckBox->setChecked((filter_.getCommunicationKinds() & CommunicationKind::Synchronizing)==CommunicationKind::Synchronizing); + + connect(collectiveCheckBox, &QCheckBox::toggled, [this] { + if(collectiveCheckBox->isChecked()){ + synchoCheckBox->setChecked(collectiveCheckBox->isChecked()); + synchoCheckBox->setDisabled(collectiveCheckBox->isChecked()); + }else synchoCheckBox->setDisabled(false); + }); + + // Slot layout + auto vboxSlot = new QVBoxLayout(); + vboxSlot->addWidget(mpiSlotKindCheckBox); + vboxSlot->addWidget(openMpSlotKindCheckBox); + vboxSlot->addWidget(plainSlotKindCheckBox); + + vboxSlot->addStretch(1); + slotKindsGroupBox->setLayout(vboxSlot); + + // Communication layouts + auto vboxPointToPointCommunication = new QVBoxLayout(); + vboxPointToPointCommunication->addWidget(pointToPointCheckBox); + vboxPointToPointCommunication->addWidget(blockingPointToPointCheckBox); + vboxPointToPointCommunication->addWidget(nonBlockingPointToPointCheckBox); + pointToPointCommunicationKindsGroupBox->setLayout(vboxPointToPointCommunication); + + auto vboxCollectivCommunication = new QVBoxLayout(); + vboxCollectivCommunication->addWidget(collectiveCheckBox); + vboxCollectivCommunication->addWidget(synchoCheckBox); + collectivCommunicationKindsGroupBox->setLayout(vboxCollectivCommunication); + + + // MPI GroupBox to hold both communication layouts + auto mpiGroupBox = new QGroupBox(tr("MPI Communication")); + auto hboxMPI = new QHBoxLayout(); + hboxMPI->addWidget(pointToPointCommunicationKindsGroupBox); + hboxMPI->addWidget(collectivCommunicationKindsGroupBox); + mpiGroupBox->setLayout(hboxMPI); + + + + grid->addWidget(slotKindsGroupBox, 0, 0, 1, 2); + grid->addWidget(mpiGroupBox, 1, 0, 1, 2); - grid->addWidget(slotKindsGroupBox, 0, 0); auto okButton = new QPushButton(tr("&Ok")); okButton->setDefault(true); @@ -51,8 +119,8 @@ FilterPopup::FilterPopup(const Filter &filter, QWidget *parent, const Qt::Window auto cancelButton = new QPushButton(tr("&Cancel")); connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject())); - grid->addWidget(cancelButton, 1, 0, Qt::AlignLeft); - grid->addWidget(okButton, 1, 1, Qt::AlignRight); + grid->addWidget(cancelButton, 2, 0, Qt::AlignLeft); + grid->addWidget(okButton, 2, 1, Qt::AlignRight); connect(this, SIGNAL(accepted()), this, SLOT(updateFilter())); @@ -70,5 +138,15 @@ void FilterPopup::updateFilter() { filter_.setSlotKinds(slotKinds); + auto communicationKinds = static_cast( + CommunicationKind::PointToPoint * pointToPointCheckBox->isChecked() | + CommunicationKind::BlockingPointToPoint * blockingPointToPointCheckBox->isChecked() | + CommunicationKind::NonBlockingPointToPoint * nonBlockingPointToPointCheckBox->isChecked() | + CommunicationKind::Synchronizing * synchoCheckBox->isChecked() | + CommunicationKind::Collective * collectiveCheckBox->isChecked()); + + filter_.setCommunicationKind(communicationKinds); + + Q_EMIT filterChanged(filter_); } diff --git a/src/ui/windows/FilterPopup.hpp b/src/ui/windows/FilterPopup.hpp index 0f6bb7a..02e6af0 100644 --- a/src/ui/windows/FilterPopup.hpp +++ b/src/ui/windows/FilterPopup.hpp @@ -62,6 +62,12 @@ public: Q_SIGNALS: QCheckBox *mpiSlotKindCheckBox = nullptr; QCheckBox *openMpSlotKindCheckBox = nullptr; QCheckBox *plainSlotKindCheckBox = nullptr; + + QCheckBox *pointToPointCheckBox = nullptr; + QCheckBox *blockingPointToPointCheckBox = nullptr; + QCheckBox *nonBlockingPointToPointCheckBox = nullptr; + QCheckBox *collectiveCheckBox = nullptr; + QCheckBox *synchoCheckBox = nullptr; }; diff --git a/src/ui/windows/FlamegraphPopup.cpp b/src/ui/windows/FlamegraphPopup.cpp new file mode 100755 index 0000000..9edb4c9 --- /dev/null +++ b/src/ui/windows/FlamegraphPopup.cpp @@ -0,0 +1,80 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "src/ui/windows/FlamegraphPopup.hpp" + +#include +//#include + + +FlamegraphPopup::FlamegraphPopup(TraceDataProxy *data, QWidget *parent):QDialog(parent), data(data){ + this->flamegraphWindow = new QDialog(parent); + this->flamegraphWindow->setWindowFlags(Qt::Window | Qt::WindowCloseButtonHint); + this->flamegraphWindow->setWindowTitle("Flamegraph"); + //this->header = new TimelineHeader(this->data, this); + this->view = new FlamegraphView(this->data, this); + this->infoBar = new QStatusBar(this); + QFont font; + font.setPointSize(10); + this->infoBar->setFont(font); + QPalette palette; + palette.setColor(QPalette::WindowText, QColorConstants::Svg::slategray); + this->infoBar->setPalette (palette); + this->infoBar->setFixedHeight(12); + this->setAttribute(Qt::WA_DeleteOnClose); +} + +void FlamegraphPopup::openFlamegraphWindow(){ + auto * settings = ViewSettings::getInstance(); + auto ROW_HEIGHT = settings->getRowHeight(); + auto * rankThreadMap = settings->getRankThreadMap(); + QFrame *line = new QFrame; + line->setFrameShape(QFrame::HLine); + line->setFrameShadow(QFrame::Sunken); + line->setContentsMargins(0,0,0,0); + QBrush backgroundPattern = QBrush(QColorConstants::Svg::silver, Qt::Dense7Pattern); + + // Prepare the Layout + this->view->updateView(); + QVBoxLayout *popupLayout = new QVBoxLayout(); + //popupLayout->addWidget(this->header); + + popupLayout->addWidget(this->view); + this->view->setBackgroundBrush(backgroundPattern); + popupLayout->addWidget(line); + //popupLayout->addSpacing(1); + popupLayout->addWidget(this->infoBar); + connect(this->view, &FlamegraphView::statusChanged, this, &FlamegraphPopup::updateStatusbar); + this->flamegraphWindow->setLayout(popupLayout); + + // Set the Window to the right size + auto sceneHeight = this->view->getGlobalMaxHeight() + rankThreadMap->at(this->view->getRequestedRank()).second.size() * ROW_HEIGHT; + auto sceneRect = this->view->rect(); + sceneRect.setHeight(sceneHeight); + sceneRect.setWidth(sceneHeight*1.8); + this->view->scene()->setSceneRect(sceneRect); + + // Show the Window + this->flamegraphWindow->show(); +} + +void FlamegraphPopup::updateStatusbar(){ + //QFontMetrics fm(this->infoBar->font()); + //QString elidedText = fm.elidedText(this->view->statusInfo, Qt::ElideRight, this->view->width()-30); + this->infoBar->showMessage(this->view->statusInfo,0); +} \ No newline at end of file diff --git a/src/ui/windows/FlamegraphPopup.hpp b/src/ui/windows/FlamegraphPopup.hpp new file mode 100755 index 0000000..1efe7f1 --- /dev/null +++ b/src/ui/windows/FlamegraphPopup.hpp @@ -0,0 +1,46 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_FlamegraphPopup_HPP +#define MOTIV_FlamegraphPopup_HPP + +#include "src/ui/views/FlamegraphView.hpp" +#include "src/ui/TraceDataProxy.hpp" +#include "src/ui/widgets/TimelineHeader.hpp" + +#include +#include +#include + +class FlamegraphPopup : public QDialog{ +Q_OBJECT + +public: + FlamegraphPopup(TraceDataProxy *data, QWidget *parent = nullptr); + void openFlamegraphWindow(); + void updateStatusbar(); + +private: + QDialog *flamegraphWindow = nullptr; + TraceDataProxy *data = nullptr; + TimelineHeader *header = nullptr; + FlamegraphView *view = nullptr; + QStatusBar *infoBar = nullptr; +}; + +#endif //MOTIV_FlamegraphPopup_HPP \ No newline at end of file diff --git a/src/ui/windows/MainWindow.cpp b/src/ui/windows/MainWindow.cpp index 26246da..2bb291f 100644 --- a/src/ui/windows/MainWindow.cpp +++ b/src/ui/windows/MainWindow.cpp @@ -1,6 +1,9 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, + * Björn Gehrke, + * Jessica Lafontaine, + * Tomas Cirkov * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -25,14 +28,21 @@ #include #include #include +#include #include +#include +#include +#include +#include #include #include "src/models/AppSettings.hpp" #include "src/models/ColorMap.hpp" +#include "src/models/ViewSettings.hpp" #include "src/ui/ColorGenerator.hpp" #include "src/ui/ColorSynchronizer.hpp" #include "src/ui/Constants.hpp" +#include "src/ui/TraceDataProxy.hpp" #include "src/ui/widgets/License.hpp" #include "src/ui/widgets/Help.hpp" #include "src/ui/widgets/TimeInputField.hpp" @@ -46,6 +56,8 @@ #include "src/ui/widgets/infostrategies/InformationDockTraceStrategy.hpp" #include "src/ui/widgets/infostrategies/InformationDockCommunicationStrategy.hpp" #include "src/ui/widgets/infostrategies/InformationDockCollectiveCommunicationStrategy.hpp" +#include "src/ui/windows/SettingsPopup.hpp" + extern bool testRun; @@ -56,6 +68,7 @@ MainWindow::MainWindow(QString filepath) : QMainWindow(nullptr), filepath(std::m if (this->filepath.isEmpty()) { this->promptFile(); } + this->startUITimerIfPossible(); this->loadSettings(); AppSettings::getInstance().setColorConfigName(this->filepath); AppSettings::getInstance().loadColorConfigs(); @@ -135,16 +148,18 @@ void MainWindow::createMenus() { /// View Menu auto filterAction = new QAction(tr("&Filter")); - filterAction->setShortcut(tr("Ctrl+S")); + filterAction->setShortcut(tr("F1")); connect(filterAction, SIGNAL(triggered()), this, SLOT(openFilterPopup())); - auto searchAction = new QAction(tr("&Find")); - searchAction->setShortcut(tr("Ctrl+F")); - connect(searchAction, SIGNAL(triggered()), this, SLOT(openFilterPopup())); + auto settingsWindowAction = new QAction(tr("Settings")); + settingsWindowAction->setShortcut(tr("F2")); + if(!this->settingsWindow) this->settingsWindow = new SettingsPopup(this->data, this); + connect(settingsWindowAction, &QAction::triggered, this->settingsWindow, &SettingsPopup::show); - auto resetZoomAction = new QAction(tr("&Reset zoom")); - connect(resetZoomAction, SIGNAL(triggered()), this, SLOT(resetZoom())); - resetZoomAction->setShortcut(tr("Ctrl+R")); + auto hideSlidersBoxAction = new QAction(tr("Sliders"), this); + // Makes the slidersBox hideable + hideSlidersBoxAction->setShortcut(tr("F3")); + connect(hideSlidersBoxAction, &QAction::triggered, this->data, &TraceDataProxy::hideSlidersBoxRequest); auto widgetMenuCustomColors = new QMenu(tr("Custom Colors")); @@ -153,16 +168,12 @@ void MainWindow::createMenus() { auto saveAsGlobalColorsAction = new QAction(tr("&Save as gobal colors")); connect(saveAsGlobalColorsAction, SIGNAL(triggered()),this,SLOT(saveAsGlobalColors())); - - auto grayFilterAction = new QAction (tr("Grayfilter")); - connect(grayFilterAction, SIGNAL(triggered()),this,SLOT(grayFilter())); - + auto deleteCustomColorsAction = new QAction (tr("&Delete custom colors")); connect(deleteCustomColorsAction, SIGNAL(triggered()),this,SLOT(deleteCustomColors())); widgetMenuCustomColors->addAction(loadGlobalColorsAction); widgetMenuCustomColors->addAction(saveAsGlobalColorsAction); - widgetMenuCustomColors->addAction(grayFilterAction); widgetMenuCustomColors->addAction(deleteCustomColorsAction); auto widgetMenuToolWindows = new QMenu(tr("Tool Windows")); @@ -182,18 +193,11 @@ void MainWindow::createMenus() { auto viewMenu = menuBar->addMenu(tr("&View")); viewMenu->addAction(filterAction); - viewMenu->addAction(searchAction); - viewMenu->addAction(resetZoomAction); + viewMenu->addAction(settingsWindowAction); + viewMenu->addAction(hideSlidersBoxAction); viewMenu->addMenu(widgetMenuCustomColors); viewMenu->addMenu(widgetMenuToolWindows); - - /// Window menu - auto minimizeAction = new QAction(tr("&Minimize")); - minimizeAction->setShortcut(tr("Ctrl+M")); - connect(minimizeAction, SIGNAL(triggered()), this, SLOT(showMinimized())); - - auto windowMenu = menuBar->addMenu(tr("&Window")); - windowMenu->addAction(minimizeAction); + /// Help menu auto showLicenseAction = new QAction(tr("&View license")); @@ -202,7 +206,7 @@ void MainWindow::createMenus() { this->licenseWindow->show(); }); auto showHelpAction = new QAction(tr("&Show help")); - showHelpAction->setShortcut(tr("F1")); + showHelpAction->setShortcut(tr("Ctrl+H")); connect(showHelpAction, &QAction::triggered, this, [this] { if(!this->helpWindow) this->helpWindow = new Help; this->helpWindow->show(); @@ -210,7 +214,6 @@ void MainWindow::createMenus() { auto showAboutQtAction = new QAction(tr("&About Qt")); connect(showAboutQtAction, &QAction::triggered, qApp, &QApplication::aboutQt); auto showAboutAction = new QAction(tr("&About")); - showAboutAction->setShortcut(tr("Shift+F1")); connect(showAboutAction, &QAction::triggered, this, [this] { if(!this->aboutWindow) this->aboutWindow= new About; this->aboutWindow->show(); @@ -224,19 +227,17 @@ void MainWindow::createMenus() { } void MainWindow::createToolBars() { - // Top toolbar contains preview/control of whole trace -// this->topToolbar = new QToolBar(this); -// this->topToolbar->setMovable(false); -// addToolBar(Qt::TopToolBarArea, this->topToolbar); // Bottom toolbar contains control fields this->bottomToolbar = new QToolBar(this); this->bottomToolbar->setMovable(false); + //this->bottomToolbar this->addToolBar(Qt::BottomToolBarArea, this->bottomToolbar); auto bottomContainerWidget = new QWidget(this->bottomToolbar); auto containerLayout = new QHBoxLayout(bottomContainerWidget); bottomContainerWidget->setLayout(containerLayout); + this->bottomToolbar->addWidget(bottomContainerWidget); // TODO populate with initial time stamps this->startTimeInputField = new TimeInputField("Start", TimeUnit::Second, data->getFullTrace()->getStartTime(), @@ -252,11 +253,111 @@ void MainWindow::createToolBars() { connect(data, SIGNAL(beginChanged(types::TraceTime)), this->startTimeInputField, SLOT(setTime(types::TraceTime))); connect(data, SIGNAL(endChanged(types::TraceTime)), this->endTimeInputField, SLOT(setTime(types::TraceTime))); - this->bottomToolbar->addWidget(bottomContainerWidget); + QFrame *line = new QFrame; + line->setFrameShape(QFrame::VLine); + line->setFrameShadow(QFrame::Sunken); + line->setContentsMargins(0,-3,0,-3); + containerLayout->addWidget(line); + containerLayout->addSpacing(5); + + // Zoom Buttons + auto zoomInButton = new QPushButton(tr("")); + zoomInButton->setIcon(*(this->settings->getInstance()->getIcon("zoom_in"))); + zoomInButton->setIconSize(QSize(32, 32)); + + auto zoomOutButton = new QPushButton(tr("")); + zoomOutButton->setIcon(*(this->settings->getInstance()->getIcon("zoom_out"))); + zoomOutButton->setIconSize(QSize(32, 32)); + + auto resetZoomButton = new QPushButton(tr("")); + resetZoomButton->setIcon(*(this->settings->getInstance()->getIcon("zoom_fit"))); + resetZoomButton->setIconSize(QSize(32, 32)); + resetZoomButton->setToolTip("Reset Zoom\nSpace"); + resetZoomButton->setShortcut(tr("Space")); + + auto searchButton = new QPushButton(tr("")); + searchButton->setIcon(*(this->settings->getInstance()->getIcon("book"))); + searchButton->setIconSize(QSize(32, 32)); + searchButton->setToolTip("Search\nCtrl+F"); + searchButton->setShortcut(tr("Ctrl+F")); + + containerLayout->addWidget(zoomInButton); + containerLayout->addWidget(zoomOutButton); + containerLayout->addWidget(resetZoomButton); + containerLayout->addWidget(searchButton); + + connect(zoomInButton, &QPushButton::clicked, this, &MainWindow::verticalZoomIn); + connect(zoomOutButton, &QPushButton::clicked, this, &MainWindow::verticalZoomOut); + connect(resetZoomButton, &QPushButton::clicked, this, &MainWindow::resetZoom); + connect(searchButton, &QPushButton::clicked,this, &MainWindow::openSearchPopup); + + // Refresh Button + auto refreshButton = new QPushButton(tr("")); + refreshButton->setIcon(*(this->settings->getInstance()->getIcon("refresh"))); + containerLayout->addWidget(refreshButton); + refreshButton->setIconSize(QSize(32, 32)); + + connect(refreshButton, &QPushButton::clicked, this, &MainWindow::refreshView); + + // infoBar + this->infoBar = new QStatusBar(this); + this->infoLabel = new QLabel(this->infoBar); + //this->infoLabel->setAlignment(Qt::AlignLeft); + this->infoBar->addPermanentWidget(infoLabel, 1); + QFont font; + font.setPointSize(10); + this->infoBar->setFont(font); + this->infoLabel->setFont(font); + QPalette palette; + palette.setColor(QPalette::WindowText, QColorConstants::Svg::slategray); + this->infoBar->setPalette (palette); + this->infoBar->setFixedHeight(26); + this->setStatusBar(this->infoBar); + + connect(data, &TraceDataProxy::triggerUITimerStartIfPossible, this, &MainWindow::startUITimerIfPossible); + connect(data, &TraceDataProxy::triggerUITimerEndIfPossible, this, &MainWindow::endUITimerIfPossible); +} +void MainWindow::showInfo() { + + // old mode + /* + this->infoBar->setToolTip("last message: "+this->infoBar->currentMessage()); + if (MainWindow::currentUITimerValue < 0) { + this->infoLabel->setText(settings->globalMessage+" "+"error: negative drawing time"); + } else if (MainWindow::currentUITimerValue == 0) { + this->infoBar->showMessage(settings->globalMessage+" "+"<1"+" [ms]", 0); + } else { + this->infoBar->showMessage(settings->globalMessage+" "+std::to_string(MainWindow::currentUITimerValue).c_str()+" [ms]", 0); + } + */ + + // new mode + std::string timeValue; + MainWindow::currentUITimerValue==0 ? timeValue = "<1" : timeValue = std::to_string(MainWindow::currentUITimerValue); + this->infoBar->setToolTip("last message: "+this->infoLabel->text()); + if (MainWindow::currentUITimerValue < 0) { + this->infoLabel->setText(settings->globalMessage+" "+" error: negative drawing time "); + } else if (!this->settings->getColorCodingTimeRecords()) { + this->infoLabel->setText(""+settings->globalMessage+" "+timeValue.c_str()+" [ms]"+""); + } else if (MainWindow::currentUITimerValue <= 25) { + this->infoLabel->setText(settings->globalMessage+" "+""+timeValue.c_str()+""+"[ms]"); + } else if (MainWindow::currentUITimerValue <= 50) { + this->infoLabel->setText(settings->globalMessage+" "+""+timeValue.c_str()+""+"[ms]"); + } else if (MainWindow::currentUITimerValue <= 100) { + this->infoLabel->setText(settings->globalMessage+" "+""+timeValue.c_str()+""+"[ms]"); + } else if (MainWindow::currentUITimerValue <= 250) { + this->infoLabel->setText(settings->globalMessage+" "+""+timeValue.c_str()+""+"[ms]"); + } else if (MainWindow::currentUITimerValue > 250) { + this->infoLabel->setText(settings->globalMessage+" "+""+timeValue.c_str()+""+"[ms]"); + } + + settings->globalMessage=""; } + void MainWindow::createDockWidgets() { + this->information = new InformationDock(); information->addElementStrategy(new InformationDockSlotStrategy()); information->addElementStrategy(new InformationDockTraceStrategy()); @@ -273,6 +374,14 @@ void MainWindow::createDockWidgets() { this->addDockWidget(Qt::RightDockWidgetArea, this->information); this->traceOverview = new TraceOverviewDock(this->data); + QPalette palette; + palette.setColor(QPalette::WindowText, QColorConstants::Svg::slategray); + this->traceOverview->setPalette (palette); + QFont font; + font.setPointSize(10); + this->traceOverview->setFont(font); + //this->traceOverview->setWindowTitle(" Timeline - Overview"); + this->traceOverview->setWindowTitle(this->filepath.section("/", -3)); this->addDockWidget(Qt::TopDockWidgetArea, this->traceOverview); } @@ -311,6 +420,7 @@ void MainWindow::loadTrace() { auto slots = this->callbacks->getSlots(); auto communications = this->callbacks->getCommunications(); auto collectives = this->callbacks->getCollectiveCommunications(); + auto trace = new FileTrace(slots, communications, collectives, this->callbacks->duration()); this->data = new TraceDataProxy(trace, this->settings, this); @@ -321,28 +431,13 @@ void MainWindow::loadTrace() { } void MainWindow::loadSettings() { - this->settings = new ViewSettings(); + this->settings = ViewSettings::getInstance(); } void MainWindow::resetZoom() { data->setSelection(types::TraceTime(0), data->getTotalRuntime()); } -void MainWindow::grayFilter(){ - // Shows a warning message if save as global color is checked - if(AppSettings::getInstance().getuseGlobalColorConfig()){ - QMessageBox warningBox; - warningBox.setIcon(QMessageBox::Warning); - warningBox.setWindowTitle("Saving gray filter globally"); - warningBox.setText("You are about to save the color changes globally. This will affect all traces in the application. \n\nAre you sure you want to continue?"); - warningBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No); - warningBox.setDefaultButton(QMessageBox::No); - int choice = warningBox.exec(); - if(choice == QMessageBox::No) return; - } - colorsynchronizer->synchronizeColors(colors::COLOR_SLOT_PLAIN); -} - void MainWindow::deleteCustomColors(){ AppSettings::getInstance().clearColorConfig(); ColorMap::getInstance()->clearColorMap(); @@ -385,3 +480,37 @@ void MainWindow::openNewWindow(QString path) { QStringList(path)); } +void MainWindow::verticalZoomIn(){ + auto currentRowHeight=this->settings->getRowHeight(); + this->settings->setRowHeight(currentRowHeight+5); + Q_EMIT this->data->verticalZoomChanged(); +} + +void MainWindow::verticalZoomOut(){ + auto currentRowHeight=this->settings->getRowHeight(); + this->settings->setRowHeight(currentRowHeight-5); + Q_EMIT this->data->verticalZoomChanged(); +} + +void MainWindow::refreshView(){ + Q_EMIT this->data->refreshButtonPressed(); +} + +void MainWindow::openSearchPopup(){ + if(this->searchWindow == nullptr) this->searchWindow = new SearchPopup(this->data,this->information, this); + Q_EMIT this->searchWindow->searchButtonPressed(); +} + +void MainWindow::startUITimerIfPossible() { + if(!this->mainUITimer.isValid())this->mainUITimer.start(); +} + +void MainWindow::endUITimerIfPossible() { + if(this->mainUITimer.isValid()) { + auto newVal = this->mainUITimer.elapsed(); + //qInfo() << newVal << "[ms]"; + this->currentUITimerValue=newVal; + this->mainUITimer.invalidate(); + this->showInfo(); + } +} \ No newline at end of file diff --git a/src/ui/windows/MainWindow.hpp b/src/ui/windows/MainWindow.hpp index 8148825..0583971 100644 --- a/src/ui/windows/MainWindow.hpp +++ b/src/ui/windows/MainWindow.hpp @@ -22,17 +22,18 @@ #include #include #include - -#include +#include #include "src/ui/widgets/TimeInputField.hpp" #include "src/ui/TraceDataProxy.hpp" #include "src/ReaderCallbacks.hpp" +#include "src/ui/windows/SearchPopup.hpp" #include "src/ui/widgets/TraceOverviewDock.hpp" #include "src/ui/widgets/InformationDock.hpp" #include "src/ui/widgets/License.hpp" #include "src/ui/widgets/Help.hpp" #include "src/ui/widgets/About.hpp" +#include "src/ui/windows/SettingsPopup.hpp" /** * @brief The main window of the application. @@ -42,7 +43,7 @@ class MainWindow : public QMainWindow { Q_OBJECT -public: // constructors +public: // constructors & timer for the UI /** * @brief Creates a new instance of the MainWindow class. * @@ -51,6 +52,9 @@ class MainWindow : public QMainWindow { explicit MainWindow(QString filepath = QString()); ~MainWindow() override; + void startUITimerIfPossible(); + void endUITimerIfPossible(); + public: Q_SIGNALS: // TODO @@ -60,13 +64,6 @@ public Q_SLOTS: */ void resetZoom(); - /** - * @brief Applies a gray filter to all generic functions. - * - * The change is not saved in the ColorConfigFile. - */ - void grayFilter(); - /** * @brief Deletes all color settings */ @@ -92,6 +89,26 @@ public Q_SLOTS: */ void openNewTrace(); + /** + * @brief Zooms in the timeline view vertically + */ + void verticalZoomIn(); + + /** + * @brief Zooms out the timeline view vertically + */ + void verticalZoomOut(); + + /** + * @brief todo + */ + void refreshView(); + + /** + * @brief Opens and shows the SearchPopup + */ + void openSearchPopup(); + private: // methods void createMenus(); void createToolBars(); @@ -102,10 +119,13 @@ public Q_SLOTS: void loadTrace(); void loadSettings(); void openNewWindow(QString path); + void showInfo(); private: // widgets QToolBar *topToolbar = nullptr; QToolBar *bottomToolbar = nullptr; + QStatusBar *infoBar = nullptr; + QLabel *infoLabel = nullptr; InformationDock *information = nullptr; TraceOverviewDock *traceOverview = nullptr; @@ -117,6 +137,9 @@ public Q_SLOTS: Help *helpWindow = nullptr; About *aboutWindow = nullptr; + SearchPopup *searchWindow = nullptr; + SettingsPopup *settingsWindow = nullptr; + private: // properties QString filepath; TraceDataProxy *data = nullptr; @@ -125,6 +148,9 @@ public Q_SLOTS: ReaderCallbacks *callbacks = nullptr; ViewSettings *settings = nullptr; + + QElapsedTimer mainUITimer; + qint64 currentUITimerValue; }; diff --git a/src/ui/windows/MpiAnalysisWindow.cpp b/src/ui/windows/MpiAnalysisWindow.cpp new file mode 100644 index 0000000..67d3ab1 --- /dev/null +++ b/src/ui/windows/MpiAnalysisWindow.cpp @@ -0,0 +1,490 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "src/models/AppSettings.hpp" +#include "src/ui/widgets/infostrategies/InformationDockSlotStrategy.hpp" +#include "src/ui/widgets/infostrategies/InformationDockTraceStrategy.hpp" +#include "src/ui/widgets/infostrategies/InformationDockCommunicationStrategy.hpp" +#include "src/ui/widgets/infostrategies/InformationDockCollectiveCommunicationStrategy.hpp" +#include "src/ui/windows/MpiAnalysisWindow.hpp" +#include "src/ui/widgets/mpianalysis/LogicalClock.hpp" + +#include "src/models/Slot.hpp" +#include +#include + +extern bool testRun; + +MpiAnalysisWindow::MpiAnalysisWindow(QString filepath) : QMainWindow(nullptr), filepath(std::move(filepath)){ + if (this->filepath.isEmpty()) { + this->promptFile(); + } + + AppSettings::getInstance().setColorConfigName(this->filepath); + AppSettings::getInstance().setMode(MPI_Analysis); + + this->createMenus(); + this->loadTrace(); + this->createCentralWidget(); +} + +MpiAnalysisWindow::~MpiAnalysisWindow() {} + + +void MpiAnalysisWindow::createMenus(){ + auto menuBar = this->menuBar(); + + /// File menu + auto openTraceAction = new QAction(tr("&Open..."), this); + openTraceAction->setShortcut(tr("Ctrl+O")); + connect(openTraceAction, &QAction::triggered, this, &MpiAnalysisWindow::openNewTrace); + auto openRecentMenu = new QMenu(tr("&Open recent")); + if (AppSettings::getInstance().recentlyOpenedFiles().isEmpty()) { + auto emptyAction = openRecentMenu->addAction(tr("&(Empty)")); + emptyAction->setEnabled(false); + } else { + for (const auto &recent: AppSettings::getInstance().recentlyOpenedFiles()) { + auto recentAction = new QAction(recent, openRecentMenu); + openRecentMenu->addAction(recentAction); + connect(recentAction, &QAction::triggered, [&, this] { + this->openNewWindow(recent); + }); + } + openRecentMenu->addSeparator(); + + auto clearRecentMenuAction = new QAction(tr("&Clear history")); + openRecentMenu->addAction(clearRecentMenuAction); + connect(clearRecentMenuAction, &QAction::triggered, [&, openRecentMenu] { + AppSettings::getInstance().recentlyOpenedFilesClear(this->filepath); + + // Make a copy of the list of actions + QList actions = openRecentMenu->actions(); + + for (auto action : actions) { + if (action != clearRecentMenuAction && action->text()!= this->filepath) { + openRecentMenu->removeAction(action); + action->deleteLater(); + } + } + }); + } + + auto quitAction = new QAction(tr("&Quit"), this); + quitAction->setShortcut(tr("Ctrl+Q")); + connect(quitAction, SIGNAL(triggered()), this, SLOT(close())); + + auto fileMenu = menuBar->addMenu(tr("&File")); + fileMenu->addAction(openTraceAction); + fileMenu->addMenu(openRecentMenu); + fileMenu->addSeparator(); + fileMenu->addAction(quitAction); + + /// Help menu + auto showLicenseAction = new QAction(tr("&View license")); + connect(showLicenseAction, &QAction::triggered, this, [this] { + if(!this->licenseWindow) this->licenseWindow = new License; + this->licenseWindow->show(); + }); + auto showHelpAction = new QAction(tr("&Show help")); + showHelpAction->setShortcut(tr("Ctrl+H")); + connect(showHelpAction, &QAction::triggered, this, [this] { + if(!this->helpWindow) this->helpWindow = new Help; + this->helpWindow->show(); + }); + // auto showAboutQtAction = new QAction(tr("&About Qt")); + // connect(showAboutQtAction, &QAction::triggered, qApp, &QApplication::aboutQt); + // auto showAboutAction = new QAction(tr("&About")); + // connect(showAboutAction, &QAction::triggered, this, [this] { + // if(!this->aboutWindow) this->aboutWindow= new About; + // this->aboutWindow->show(); + // }); + + auto helpMenu = menuBar->addMenu(tr("&Help")); + helpMenu->addAction(showLicenseAction); + helpMenu->addAction(showHelpAction); + // helpMenu->addAction(showAboutQtAction); + // helpMenu->addAction(showAboutAction); +} + +void MpiAnalysisWindow::openNewTrace() { + auto path = this->promptFile(); + this->openNewWindow(path); +} + +//Open new Window in MPI Communication mode +void MpiAnalysisWindow::openNewWindow(QString path) { + QStringList arguments; + arguments << "-m" << "1" << path; + QProcess::startDetached(QFileInfo(QCoreApplication::applicationFilePath()).absoluteFilePath(), + arguments); +} + +void MpiAnalysisWindow::createCentralWidget(){ + QWidget *centralWidget = new QWidget(this); + + auto layout = new QGridLayout(centralWidget); + + + auto logicalClock = new LogicalClock(this->data, this->nodes, this); + + QBrush backgroundPattern = QBrush(QColorConstants::Svg::silver, Qt::Dense7Pattern); + logicalClock->setBackgroundBrush(backgroundPattern); + + layout->addWidget(logicalClock,0,1); + + createInformationWidget(); + layout->addWidget(this->information, 0,2); + layout->setAlignment(this->information, Qt::AlignRight); + + centralWidget->setLayout(layout); + this->setCentralWidget(centralWidget); + +} + +void MpiAnalysisWindow::createInformationWidget(){ + this->information = new InformationDock(); + information->addElementStrategy(new InformationDockSlotStrategy()); + information->addElementStrategy(new InformationDockTraceStrategy()); + information->addElementStrategy(new InformationDockCommunicationStrategy()); + information->addElementStrategy(new InformationDockCollectiveCommunicationStrategy()); + + this->information->setElement(this->data->getFullTrace()); + // @formatter:off + connect(information, SIGNAL(zoomToWindow(types::TraceTime, types::TraceTime)), data, + SLOT(setSelection(types::TraceTime, types::TraceTime))); + + connect(data, SIGNAL(infoElementSelected(TimedElement * )), information, SLOT(setElement(TimedElement * ))); + +} + +QString MpiAnalysisWindow::promptFile() { + auto newFilePath = QFileDialog::getOpenFileName(this, QFileDialog::tr("Open trace"), QString(), + QFileDialog::tr("OTF Traces (*.otf *.otf2)")); + + // TODO this is still not really a great way to deal with that, especially for the initial open + if (newFilePath.isEmpty()) { + auto errorMsg = new QErrorMessage(nullptr); + errorMsg->showMessage("The chosen file is invalid!"); + } + + return newFilePath; +} + +void MpiAnalysisWindow::loadTrace() { + + QElapsedTimer loadTraceTimer; + if(testRun==true){ + loadTraceTimer.start(); + } + + this->reader = new otf2::reader::reader(this->filepath.toStdString()); + + this->callbacks = new ReaderCallbacks(*reader); + + this->reader->set_callback(*callbacks); + this->reader->read_definitions(); + this->reader->read_events(); + + + auto slots = this->callbacks->getSlots(); + auto communications = this->callbacks->getCommunications(); + auto collectives = this->callbacks->getCollectiveCommunications(); + + auto trace = new FileTrace(slots, communications, collectives, this->callbacks->duration()); + + this->data = new TraceDataProxy(trace, this->settings, this); + this->buildNodes(); + + if(testRun==true){ + std::cout << "%MpiAnalysisWindow::loadTrace()%" << loadTraceTimer.elapsed() << "%ms%"; + } +} + +// constexpr size_t IDX_P2P_EVENTS = 0; +// constexpr size_t IDX_COLLECTIVES_EVENTS = 1; + +constexpr size_t IDX_NODES = 0; +constexpr size_t IDX_COMMUNICATIONS = 1; + +constexpr size_t IDX_BARRIER = 0; +constexpr size_t IDX_COLL_ONE2ALL = 1; +constexpr size_t IDX_ALL2ONE = 2; +constexpr size_t IDX_COLL_ALL2ALL = 3; +constexpr size_t IDX_OTHER = 4; + + +void MpiAnalysisWindow::buildNodes(){ + + // Pending Events: Connects Slots with corresponding CommunicationEvents (P2P or collective communication). + using pendingP2PEvents = std::tuple, std::vector>; + using pendingCollectivesEvents = std::tuple, std::vector>; + + std::map pendingP2PMap; + std::map pendingCollectiveMap; + + // Pending non-blocking Nodes awaiting connection with potential subsequent mpi_wait + std::map> pendingNodesForWait; + + // Pending Node to connect with matching Node (e.g sender, receiver), key is their CommunicationEvent + std::map pendingNodesP2P; + + // std::map pendingNodesCollectives; + std::map> pendingNodesCollectives; + + + std::unordered_set collectiveRoles ={ + otf2::common::role_type::barrier, + otf2::common::role_type::coll_one2all, + otf2::common::role_type::coll_all2one, + otf2::common::role_type::coll_all2all, + otf2::common::role_type::coll_other, + }; + + for(auto &item: data->getFullTrace()->getSlots()){ + for(auto &slot: item.second){ + Node* node_ = new Node(slot); + QString regionName = QString::fromStdString(slot->region->name().str()); + auto DEBUG_REGION_NAME = slot->region->name().str(); + auto roleType = slot->region->role(); + auto location = slot->location->ref(); + + + // Pending non-blocking nodes awaiting upcoming wait operations + if(regionName.contains("MPI_I") && roleType != otf2::common::role_type::function){ + if(pendingNodesForWait.find(location)==pendingNodesForWait.end()) pendingNodesForWait[location] = std::vector(); + pendingNodesForWait[location].push_back(node_); + } + + if(roleType == otf2::common::role_type::point2point){ + if (pendingP2PMap.find(location) == pendingP2PMap.end()) pendingP2PMap[location] = pendingP2PEvents(); + std::get(pendingP2PMap[location]).push_back(node_); + + }else // Pending nodes with collective communications + if(collectiveRoles.find(roleType) != collectiveRoles.end()){ + if (pendingCollectiveMap.find(location) == pendingCollectiveMap.end()) pendingCollectiveMap[location] = pendingCollectivesEvents(); + std::get(pendingCollectiveMap[location]).push_back(node_); + }else + + // Connecting wait-nodes with operation nodes + if(regionName.contains("wait", Qt::CaseInsensitive)){ + if(pendingNodesForWait.find(location)==pendingNodesForWait.end() || pendingNodesForWait[location].empty()) { + throw std::runtime_error("Attempted to wait for a non-blocking operation at location " + std::to_string(location) + ", but no preceding non-blocking operation was initiated."); + } + if(regionName=="MPI_Wait"){ + node_->addConnectedNode(pendingNodesForWait[location].front()); + pendingNodesForWait[location].erase(pendingNodesForWait[location].begin()); + }else{ + node_->addConnectedNode(location, pendingNodesForWait[location]); + pendingNodesForWait.erase(location); + } + } + + this->nodes[location].push_back(node_); + } + + } + + //Pending communications + for(auto &item: data->getFullTrace()->getCommunications()){ + const auto startEvent = item->getStartEvent(); + const auto endEvent = item->getEndEvent(); + auto startLoc = startEvent->getLocation()->ref(); + auto endLoc = endEvent->getLocation()->ref(); + + if (pendingP2PMap.find(startLoc) == pendingP2PMap.end()) pendingP2PMap[startLoc] = pendingP2PEvents(); + if (pendingP2PMap.find(endLoc) == pendingP2PMap.end()) pendingP2PMap[endLoc] = pendingP2PEvents(); + + // if(startLoc != endLoc){ + std::get(pendingP2PMap[startLoc]).push_back(item); + std::get(pendingP2PMap[endLoc]).push_back(item); + // } else std::get<1>(pendingMap[startLoc]).push_back(item); + } + + // Resort P2P communication by rank + for (auto &item : pendingP2PMap) { + auto locationKey = item.first; + auto &communications = std::get(item.second); + std::sort(communications.begin(), communications.end(), + [this, locationKey](Communication* a, Communication* b) { + return this->customP2PCommunicationCompare(a, b, locationKey); + }); + } + + //Pending collective communications + for(auto &item: data->getFullTrace()->getCollectiveCommunications()){ + if(getTypeIndex(item->getOperation()) == IDX_OTHER) continue; + for(auto &member: item->getMembers()){ + auto memberLocation = member->getLocation()->ref(); + if(pendingCollectiveMap.find(memberLocation) == pendingCollectiveMap.end()) pendingCollectiveMap[memberLocation] = pendingCollectivesEvents(); + std::get(pendingCollectiveMap[memberLocation]).push_back(item); + } + } + + //Adds communication to matching Node + for (auto &locationEntry : pendingP2PMap) { + auto &communications = std::get(locationEntry.second); + auto &nodes_ = std::get(locationEntry.second); + + bool sizeMatchP2P = (nodes_.size()==communications.size()); + + for (auto node : nodes_){ + auto slot = node->getSlot(); + // QString regionName = QString::fromStdString(slot->region->name().str()); + + if(!communications.empty()){ + // Less communication events than nodes, some communications seem unfinished. + if(!sizeMatchP2P){ + if(communications.front()->getStartEvent()->getLocation()->ref() == node->getLocation()){ + if(!timeMatching(communications.front()->getStartEvent(), *slot)) continue; + } else if(!timeMatching(communications.front()->getEndEvent(), *slot)) continue; + } + node->setCommunication(communications.front()); + + // Add connected Nodes + if(pendingNodesP2P.find(communications.front()) == pendingNodesP2P.end()) pendingNodesP2P[communications.front()] = node; + else { + node->addConnectedNode(pendingNodesP2P[communications.front()]); + pendingNodesP2P[communications.front()]->addConnectedNode(node); + } + communications.erase(communications.begin()); + if(QString::fromStdString(node->getSlot()->region->name().str()).contains("sendrecv",Qt::CaseInsensitive)) communications.erase(communications.begin()); + } + } + + } + + //Adds collective communication to matching Node + for (auto &locationEntry : pendingCollectiveMap){ + for (auto node : std::get(locationEntry.second)) { + auto &collectives = std::get(locationEntry.second); + + if(!collectives.empty()){ + node->setCollectiveCommunication(collectives.front()); + auto event = collectives.front(); + // Pending member for connectedNodes + if(pendingNodesCollectives.find(event) == pendingNodesCollectives.end()) pendingNodesCollectives[event] = std::vector(); + pendingNodesCollectives[event].push_back(node); + collectives.erase(collectives.begin()); + } + } + } + + // Add connectedNodes + for(auto &collectiveCommunication : pendingNodesCollectives) { + std::vector& nodes = collectiveCommunication.second; + for(auto node : nodes){ + node->addConnectedNode(nodes); + } + } +} + +bool MpiAnalysisWindow::customP2PCommunicationCompare(Communication* a, Communication* b, uint64_t locationKey) { + auto startEventA = a->getStartEvent(); + auto startEventB = b->getStartEvent(); + + auto EndEventA = a->getEndEvent(); + auto EndEventB = b->getEndEvent(); + + bool isStartEventAMatching = startEventA->getLocation()->ref() == locationKey; + bool isStartEventBMatching = startEventB->getLocation()->ref() == locationKey; + + auto timeA = isStartEventAMatching ? startEventA->getStartTime() : EndEventA->getStartTime(); + auto timeB = isStartEventBMatching ? startEventB->getStartTime() : EndEventB->getStartTime(); + + return timeA < timeB; +} + +bool MpiAnalysisWindow::timeMatching(const CommunicationEvent* event, Slot slot){ + auto startTime = event->getStartTime(); + auto endTime = event->getEndTime(); + + auto differenceStart = abs(event->getStartTime() - slot.startTime); + auto differenceEnd = abs(event->getEndTime() - slot.endTime); + std::chrono::nanoseconds threshold(500000); + if(differenceStart < threshold || differenceEnd < threshold) return true; + else return false; +} + +size_t MpiAnalysisWindow::getTypeIndex(otf2::common::collective_type collectiveType){ + switch(collectiveType){ + case otf2::common::collective_type::barrier: + return IDX_BARRIER; + case otf2::common::collective_type::broadcast: + case otf2::common::collective_type::scatter: + case otf2::common::collective_type::scatterv: + return IDX_COLL_ONE2ALL; + case otf2::common::collective_type::gather: + case otf2::common::collective_type::gatherv: + case otf2::common::collective_type::reduce: + return IDX_ALL2ONE; + case otf2::common::collective_type::all_gather: + case otf2::common::collective_type::all_gatherv: + case otf2::common::collective_type::all_to_all: + case otf2::common::collective_type::all_to_allv: + case otf2::common::collective_type::all_to_allw: + case otf2::common::collective_type::all_reduce: + case otf2::common::collective_type::reduce_scatter: + case otf2::common::collective_type::reduce_scatter_block: + case otf2::common::collective_type::scan: + case otf2::common::collective_type::exscan: + return IDX_COLL_ALL2ALL; + case otf2::common::collective_type::create_handle: + case otf2::common::collective_type::destroy_handle: + case otf2::common::collective_type::allocate: + case otf2::common::collective_type::deallocate: + case otf2::common::collective_type::create_handle_and_allocate: + case otf2::common::collective_type::destroy_handle_and_deallocate: + return IDX_OTHER; + default: + return IDX_OTHER; + } +} + +size_t MpiAnalysisWindow::getTypeIndex(otf2::common::role_type roleType){ + switch(roleType){ + case otf2::common::role_type::barrier: + return IDX_BARRIER; + case otf2::common::role_type::coll_one2all: + return IDX_COLL_ONE2ALL; + case otf2::common::role_type::coll_all2one: + return IDX_ALL2ONE; + case otf2::common::role_type::coll_all2all: + return IDX_COLL_ALL2ALL; + default: + return IDX_OTHER; + } +} \ No newline at end of file diff --git a/src/ui/windows/MpiAnalysisWindow.hpp b/src/ui/windows/MpiAnalysisWindow.hpp new file mode 100644 index 0000000..3b43514 --- /dev/null +++ b/src/ui/windows/MpiAnalysisWindow.hpp @@ -0,0 +1,95 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2024 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_MPIANALYSISWINDOW_HPP +#define MOTIV_MPIANALYSISWINDOW_HPP + +#include +#include + + +#include "src/ReaderCallbacks.hpp" +#include "src/models/communication/CommunicationEvent.hpp" +#include "src/models/Slot.hpp" +#include "src/models/mpianalysis/Node.hpp" +#include "src/ui/TraceDataProxy.hpp" +#include "src/ui/widgets/Help.hpp" +#include "src/ui/widgets/InformationDock.hpp" +#include "src/ui/widgets/License.hpp" + + + +//#include "src/ui/widgets/About.hpp" + +class MpiAnalysisWindow : public QMainWindow { + Q_OBJECT + +public: // constructors & timer for the UI + /** + * @brief Creates a new instance of the MpiAnalysisWindow class. + * + * @param filepath Path to trace file. If omitted the user is promted for it. + */ + explicit MpiAnalysisWindow(QString filepath = QString()); + ~MpiAnalysisWindow() override; + +public Q_SLOTS: + /** + * @brief Asks for a new trace file and opens the trace + */ + void openNewTrace(); + +private: // methods + void createMenus(); + void createCentralWidget(); + void createInformationWidget(); + void openNewWindow(QString path); + + void loadTrace(); + void buildNodes(); + + bool customP2PCommunicationCompare(Communication* a, Communication* b, uint64_t locationKey); + bool timeMatching(const CommunicationEvent* event, Slot slot); + size_t getTypeIndex(otf2::common::collective_type collectiveType); + size_t getTypeIndex(otf2::common::role_type roleType); + + QString promptFile(); + + //void showInfo(); + +private: // widgets + // QStatusBar *infoBar = nullptr; + // QLabel *infoLabel = nullptr; + InformationDock *information = nullptr; + + License *licenseWindow = nullptr; + Help *helpWindow = nullptr; + //About *aboutWindow = nullptr; + +private: // properties + QString filepath; + TraceDataProxy *data = nullptr; + std::map> nodes; + + otf2::reader::reader *reader = nullptr; + ReaderCallbacks *callbacks = nullptr; + + ViewSettings *settings = nullptr; +}; + +#endif //MOTIV_MPIANALYSISWINDOW_HPP \ No newline at end of file diff --git a/src/ui/windows/SearchPopup.cpp b/src/ui/windows/SearchPopup.cpp new file mode 100644 index 0000000..202b0da --- /dev/null +++ b/src/ui/windows/SearchPopup.cpp @@ -0,0 +1,182 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include + +#include "src/models/Search.hpp" +#include "src/ui/windows/SearchPopup.hpp" + +SearchPopup::SearchPopup(TraceDataProxy *data, InformationDock *information, QWidget *parent):data(data), information(information), QDialog(parent){ + this->buildWindow(parent); +} + +void SearchPopup::buildWindow(QWidget *parent){ + // Build search window + this->searchWindow = new QDialog(parent); + searchWindow->setWindowFlags(Qt::Window); + searchWindow->setWindowTitle("Search"); + + auto layout = new QVBoxLayout(searchWindow); + + auto searchEdit = new QLineEdit(searchWindow); + searchEdit->setPlaceholderText("search"); + layout->addWidget(searchEdit); + + auto itemList = new QListWidget(searchWindow); + itemList->setSelectionMode(QAbstractItemView::NoSelection); + + + auto search_ = new Search(data, itemList, parent); + layout->addWidget(itemList); + + searchWindow->setLayout(layout); + + auto buttonLayout = new QHBoxLayout(searchWindow); + layout->addLayout(buttonLayout); + + // Next and previous buttons + auto prevButton = new QPushButton(tr("prev"), this); + prevButton->setEnabled(false); + buttonLayout->addWidget(prevButton); + + auto nextButton = new QPushButton(tr("next"),this); + nextButton->setEnabled(false); + buttonLayout->addWidget(nextButton); + + // Enables or disables the buttons + connect(this, &SearchPopup::itemSelected, this, [this, prevButton, nextButton](bool selected) { + if (selected){ + prevButton->setEnabled(true); + nextButton->setEnabled(true); + + prevButton->setStyleSheet(""); + nextButton->setStyleSheet(""); + } else { + prevButton->setEnabled(false); + nextButton->setEnabled(false); + + prevButton->setStyleSheet("background-color: #d3d3d3;"); + nextButton->setStyleSheet("background-color: #d3d3d3;"); + } + }); + + // Zooms into the previous found slot + connect(prevButton, &QPushButton::clicked ,this, [this]{ + selectSlot(ButtonType::PREV); + auto element_= *currentIterator; + + //Q_EMIT this->information->zoomToWindow((*currentIterator)->getStartTime(), (*currentIterator)->getEndTime()); + auto padding = element_->getDuration() / 10; + Q_EMIT this->information->zoomToWindow(element_->getStartTime() - padding, element_->getEndTime() + padding); + }); + + // Zooms into the next found slot + connect(nextButton,&QPushButton::clicked ,this, [this]{ + selectSlot(ButtonType::NEXT); + auto element_= *currentIterator; + + //Q_EMIT this->information->zoomToWindow((*currentIterator)->getStartTime(), (*currentIterator)->getEndTime()); + auto padding = element_->getDuration() / 10; + Q_EMIT this->information->zoomToWindow(element_->getStartTime() - padding, element_->getEndTime() + padding); + }); + + + // Connects + // Opens the search popup window + connect(this, SIGNAL(searchButtonPressed()), this, SLOT(openSearchWindow())); + + // Updates the list of found elements based on the input + connect(searchEdit, &QLineEdit::textChanged, this, [searchEdit, itemList, search_] { + QString text = searchEdit->text(); + search_->findName(text, itemList); + }); + + // Handles highlighting of selected element + connect(itemList, &QListWidget::itemPressed, this, [this, itemList]{ + if(this->selectedItem_ == nullptr || itemList->currentItem()->text()!=selectedItem_->text()){ + if(this->selectedItem_!= nullptr) this->selectedItem_->setForeground(Qt::black); + this->selectedItem_ = itemList->currentItem(); + this->selectedItem_->setForeground(Qt::blue); + + ViewSettings::getInstance()->setSearchName(itemList->currentItem()->text()); + this->firstNextUse=true; + + auto search_ = new Search(data, itemList, this); + this->slotList = search_->createItemList(itemList->currentItem()->text()); + this->currentIterator=slotList.begin(); + this->selectSlot(); + Q_EMIT this->data->refreshButtonPressed(); + } + else{ + this->selectedItem_->setForeground(Qt::black); + this->selectedItem_ = nullptr; + this->information->setElement(nullptr); + ViewSettings::getInstance()->setSearchName(""); + Q_EMIT this->data->refreshButtonPressed(); + Q_EMIT this->itemSelected(false); + } + }); + + // Handles highlighting with "Enter" key in search box + connect(searchEdit, &QLineEdit::returnPressed, this, [this, searchEdit]{ + ViewSettings::getInstance()->setSearchName(searchEdit->text()); + Q_EMIT this->data->refreshButtonPressed(); + }); + + // Remove highlighting when the search window is closed + connect(searchWindow, &QDialog::finished, this, [this]{ + ViewSettings::getInstance()->setSearchName(""); + Q_EMIT this->data->refreshButtonPressed(); + Q_EMIT this->itemSelected(false); + }); +} + +void SearchPopup::selectSlot(ButtonType buttenType){ + switch(buttenType){ + //none + case ButtonType::NONE: + information->setElement(*currentIterator); + Q_EMIT itemSelected(true); + break; + + //prev + case ButtonType::PREV: + if(currentIterator!=slotList.begin()) --currentIterator; + else currentIterator=std::prev(slotList.end()); + information->setElement(*currentIterator); + Q_EMIT itemSelected(true); + break; + + //next + case ButtonType::NEXT: + if(currentIterator!=std::prev(slotList.end()) && firstNextUse!=true) ++currentIterator; + else currentIterator=slotList.begin(); + information->setElement(*currentIterator); + firstNextUse=false; + Q_EMIT itemSelected(true); + break; + } +} + +void SearchPopup::openSearchWindow(){ + this->searchWindow->show(); + this->searchWindow->activateWindow(); +} \ No newline at end of file diff --git a/src/ui/windows/SearchPopup.hpp b/src/ui/windows/SearchPopup.hpp new file mode 100644 index 0000000..361d214 --- /dev/null +++ b/src/ui/windows/SearchPopup.hpp @@ -0,0 +1,100 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Jessica Lafontaine + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef MOTIV_SearchPopup_HPP +#define MOTIV_SearchPopup_HPP + +#include +#include +#include +#include + +#include "src/ui/widgets/InformationDock.hpp" + +enum ButtonType { + NONE, + PREV, + NEXT +}; + +/** + * @brief Manages a popup window for searching and highlighting slots in the user interface. + */ +class SearchPopup : public QDialog{ +Q_OBJECT + +public: + SearchPopup(TraceDataProxy *data, InformationDock *information, QWidget *parent = nullptr); + +public: Q_SIGNALS: + + /** + * @brief Signal indicating that the search button in the main window was pressed + */ + void searchButtonPressed(); + + /** + * @brief Signal indicating that the previous button in the search window was pressed + */ + void prevButtonPressed(); + + /** + * @brief Signal indicating that the next button in the search window was pressed + */ + void nextButtonPressed(); + + /** + * @brief Signal representing whether an item is selected or not. + * + * @param selected True if an item is selected + * @note This signal manages the interactivity of the "next" and "prev" buttons. + */ + void itemSelected(bool selected); + +private Q_SLOTS: + + /** + * @brief Displays the search popup window. + */ + void openSearchWindow(); + + /** + * @brief Handles enabling or disabling "next" and "prev" buttons. + */ + void selectSlot(ButtonType state = ButtonType::NONE); + +private: + + /** + * @brief Builds the search window. + */ + void buildWindow(QWidget* parent); + + +private: + QDialog *searchWindow = nullptr; + QListWidgetItem *selectedItem_ = nullptr; + std::list slotList; + std::list::iterator currentIterator; + bool firstNextUse = true; + + TraceDataProxy *data; + InformationDock *information; +}; + +#endif //MOTIV_SearchPopup_HPP \ No newline at end of file diff --git a/src/ui/windows/SettingsPopup.cpp b/src/ui/windows/SettingsPopup.cpp new file mode 100644 index 0000000..f216728 --- /dev/null +++ b/src/ui/windows/SettingsPopup.cpp @@ -0,0 +1,192 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + + +#include "src/ui/windows/SettingsPopup.hpp" + +#include +#include +#include +#include + +SettingsPopup::SettingsPopup(TraceDataProxy *data, QWidget *parent):QDialog(parent), data(data){ + + this->setWindowFlags(Qt::Window | Qt::WindowCloseButtonHint); + this->setWindowTitle(tr("Settings")); + this->setModal(true); + + auto settings = ViewSettings::getInstance(); + + auto *grid = new QGridLayout(); + + // Show settings for the main window scenery (rendered via TimelineView) + + // General - start + auto mainWindowGeneralSettings = new QGroupBox(tr("Main window - general")); + useRealWidthMainWindow = new QCheckBox(tr("Use real width for regions/functions")); + useRealWidthMainWindow->setToolTip("If this option is unchecked you will have:\n\t* Generally easier navigation, since functions are then limited in their minimum size and thus can't get extremly tiny\n\t* visible function collisions, especially if the option below (use of priority levels) is also unchecked!"); + useRealWidthMainWindow->setToolTipDuration(600000); + useRealWidthMainWindow->setChecked(settings->getUseRealWidthMainWindow()); + usePriorityOverview = new QCheckBox(tr("Use priority levels to elevate functions/regions")); + usePriorityOverview->setToolTip("If this option is unchecked functions will have their priority based on their length only: \npriority <=> 1/duration, which means smaller duration <=> higher priority!"); + usePriorityOverview->setToolTipDuration(600000); + usePriorityOverview->setChecked(settings->getUsePriorityOverview()); + absoluteDurationsForSliders = new QCheckBox(tr("Use absolute durations for active threshold sliders")); + absoluteDurationsForSliders->setToolTip("For example: assuming that a function runs for 5 min but our current selection only shows the first half,\nis this function visible with an active threshold equal to 3 min?\n\n\t* IF this checkbox is checked we will compare 5min (absolute duration) < 3min, which is false => the function will be invisible!\n\n\t* Otherwise we will compare 2.5min (drawn duration) < 3min, which is true => it will be visible!"); + absoluteDurationsForSliders->setToolTipDuration(600000); + absoluteDurationsForSliders->setChecked(settings->getAbsoluteDurationsForSliders()); + useREGSliderForOV = new QCheckBox(tr("Use the active threshold slider REG for selection *and* overview")); + useREGSliderForOV->setToolTip("This allows a more synchronized relationship between overview and selection, although there are possible downsides:\nThe filter process via the OV-slider doesn't depend on the selection width, with this option checked the overview might change drastically with zoom or selection events!\n\nHint: It's possible to move through the trace with a constant selection width via Shift+Scrolling."); + useREGSliderForOV->setToolTipDuration(600000); + useREGSliderForOV->setChecked(settings->getUseREGSliderForOV()); + + auto mainWindowGeneralSettingsLayout = new QVBoxLayout(); + mainWindowGeneralSettingsLayout->addWidget(useRealWidthMainWindow); + mainWindowGeneralSettingsLayout->addWidget(usePriorityOverview); + mainWindowGeneralSettingsLayout->addWidget(absoluteDurationsForSliders); + mainWindowGeneralSettingsLayout->addWidget(useREGSliderForOV); + + + mainWindowGeneralSettings->setLayout(mainWindowGeneralSettingsLayout); + // General - end + + // Performance - start + auto mainWindowPerformanceSettings = new QGroupBox(tr("Main window - performance")); + countIndicatorsREG = new QCheckBox(tr("Count all traced regions/functions: <#drawn> / <#all> [REG]")); + countIndicatorsREG->setChecked(settings->getCountIndicatorsREG()); + countIndicatorsP2P = new QCheckBox(tr("Count all traced point-to-point comm.: <#drawn> / <#all> [P2P]")); + countIndicatorsP2P->setChecked(settings->getCountIndicatorsP2P()); + countIndicatorsCCM = new QCheckBox(tr("Count all traced collective comm. <#drawn> / <#all> [CCM]")); + countIndicatorsCCM->setChecked(settings->getCountIndicatorsCCM()); + + auto mainWindowPerformanceSettingsLayout = new QVBoxLayout(); + mainWindowPerformanceSettingsLayout->addWidget(countIndicatorsREG); + mainWindowPerformanceSettingsLayout->addWidget(countIndicatorsP2P); + mainWindowPerformanceSettingsLayout->addWidget(countIndicatorsCCM); + + mainWindowPerformanceSettings->setLayout(mainWindowPerformanceSettingsLayout); + // Performance - end + + + // Show settings for flamegraphs (rendered via FlamegraphView) + + // General - start + auto flamegraphWindowGeneralSettings = new QGroupBox(tr("Flamegraphs - general")); + useRealWidthFlamegraph = new QCheckBox(tr("Use real width for regions/functions")); + useRealWidthFlamegraph->setToolTip("Unchecking this option is not recommended: \nWhile it appears to be a similar trade-off like the one in the main window (easier navigation for possible collisions), \nwe actually might have even worse navigation, because the collisions can cause false call hierarchies!"); + useRealWidthFlamegraph->setToolTipDuration(600000); + useRealWidthFlamegraph->setChecked(settings->getUseRealWidthFlamegraph()); + + auto flamegraphWindowGeneralSettingsLayout = new QVBoxLayout(); + flamegraphWindowGeneralSettingsLayout->addWidget(useRealWidthFlamegraph); + + flamegraphWindowGeneralSettings->setLayout(flamegraphWindowGeneralSettingsLayout); + // General - end + + // Performance - start + auto flamegraphWindowPerformanceSettings = new QGroupBox(tr("Flamegraphs - performance")); + countIndicatorDetailsFlamegraph = new QCheckBox(tr("Show missing regions/functions-traces by name")); + countIndicatorDetailsFlamegraph->setChecked(settings->getCountIndicatorDetailsFlamegraph()); + useThresholdFlamegraph = new QCheckBox(tr("Use 1px-threshold for drawing")); + useThresholdFlamegraph->setToolTip("Unchecking this option is not recommended: \nTo stack functions that are very close to each other and smaller than this can cause false hierarchies"); + useThresholdFlamegraph->setToolTipDuration(600000); + useThresholdFlamegraph->setChecked(settings->getPxThresholdFlamegraph()); + + auto flamegraphWindowPerformanceSettingsLayout = new QVBoxLayout(); + flamegraphWindowPerformanceSettingsLayout->addWidget(countIndicatorDetailsFlamegraph); + flamegraphWindowPerformanceSettingsLayout->addWidget(useThresholdFlamegraph); + + flamegraphWindowPerformanceSettings->setLayout(flamegraphWindowPerformanceSettingsLayout); + // Performance - end + + + // Overview options + auto overviewSettings = new QGroupBox(tr("Overview")); + useBorderOverview = new QCheckBox(tr("Draw borders for functions/regions")); + useBorderOverview->setChecked(settings->getUseBorderOverview()); + + auto overviewSettingsLayout = new QVBoxLayout(); + overviewSettingsLayout->addWidget(useBorderOverview); + overviewSettingsLayout->addStretch(1); + + overviewSettings->setLayout(overviewSettingsLayout); + + + // Misc options + auto miscSettings = new QGroupBox(tr("Misc")); + colorCodingTimeRecords = new QCheckBox(tr("Colorize time records for <=25/50/100/250[ms]")); + colorCodingTimeRecords->setChecked(settings->getColorCodingTimeRecords()); + + auto miscSettingsLayout = new QVBoxLayout(); + miscSettingsLayout->addWidget(colorCodingTimeRecords); + miscSettingsLayout->addStretch(1); + + miscSettings->setLayout(miscSettingsLayout); + + + // These share their row + grid->addWidget(mainWindowGeneralSettings, 0, 0); + grid->addWidget(flamegraphWindowGeneralSettings, 0, 1); + grid->addWidget(mainWindowPerformanceSettings, 1, 0); + grid->addWidget(flamegraphWindowPerformanceSettings, 1, 1); + // These don't share their row <=> addStretch(1) + grid->addWidget(overviewSettings, 2, 0); + grid->addWidget(miscSettings, 3, 0); + + // Buttons + auto okButton = new QPushButton(tr("&Ok")); + connect(okButton, &QPushButton::clicked, this, &QDialog::accept); + auto cancelButton = new QPushButton(tr("&Cancel")); + connect(cancelButton, &QPushButton::clicked, this, &QDialog::reject); + + okButton->setDefault(true); + + grid->addWidget(cancelButton, 4, 0, Qt::AlignLeft); + grid->addWidget(okButton, 4, 1, Qt::AlignRight); + + connect(this, &QDialog::accepted, this, &SettingsPopup::checkSettings); + + // Finish + this->setLayout(grid); +} + +void SettingsPopup::checkSettings() { + auto settings = ViewSettings::getInstance(); + + // Updates for main window settings + settings->setUseRealWidthMainWindow(this->useRealWidthMainWindow->isChecked()); + settings->setUsePriorityOverview(this->usePriorityOverview->isChecked()); + settings->setAbsoluteDurationsForSliders(this->absoluteDurationsForSliders->isChecked()); + settings->setUseREGSliderForOV(this->useREGSliderForOV->isChecked()); + settings->setCountIndicatorsREG(this->countIndicatorsREG->isChecked()); + settings->setCountIndicatorsP2P(this->countIndicatorsP2P->isChecked()); + settings->setCountIndicatorsCCM(this->countIndicatorsCCM->isChecked()); + + // Updates for flamegraphs + settings->setUseRealWidthFlamegraph(this->useRealWidthFlamegraph->isChecked()); + settings->setCountIndicatorDetailsFlamegraph(this->countIndicatorDetailsFlamegraph->isChecked()); + settings->setPxThresholdFlamegraph(this->useThresholdFlamegraph->isChecked()); + + // Updates for overview + settings->setUseBorderOverview(this->useBorderOverview->isChecked()); + + // Misc updates + settings->setColorCodingTimeRecords(this->colorCodingTimeRecords->isChecked()); + + Q_EMIT this->data->refreshButtonPressed(); +} \ No newline at end of file diff --git a/src/ui/windows/SettingsPopup.hpp b/src/ui/windows/SettingsPopup.hpp new file mode 100644 index 0000000..03fbf24 --- /dev/null +++ b/src/ui/windows/SettingsPopup.hpp @@ -0,0 +1,69 @@ +/* + * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) + * Copyright (C) 2023 Tomas Cirkov + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#ifndef MOTIV_SETTINGSPOPUP_HPP +#define MOTIV_SETTINGSPOPUP_HPP + +#include "src/ui/TraceDataProxy.hpp" + +#include +#include +#include + +/** + * @brief A simple popup showing performance options. + * + * In this popup, all possible performance settings can be changed. The relevant data is stored in ViewSettings, which than is considered during the render process in TimelineView or FlamegraphView. + */ +class SettingsPopup : public QDialog { +Q_OBJECT + +public: // constructors + explicit SettingsPopup(TraceDataProxy *data, QWidget *parent = nullptr); + void checkSettings(); + +private: // widgets + //QDialog *PerformancePopupWindow = nullptr; + TraceDataProxy *data = nullptr; + + // Main window general settings + QCheckBox *useRealWidthMainWindow = nullptr; + QCheckBox *usePriorityOverview = nullptr; + + // Main window performance settings + QCheckBox *countIndicatorsREG = nullptr; + QCheckBox *countIndicatorsP2P = nullptr; + QCheckBox *countIndicatorsCCM = nullptr; + + // Flamegraph general settings + QCheckBox *useRealWidthFlamegraph = nullptr; + + // Flamegraph performance settings + QCheckBox *countIndicatorDetailsFlamegraph = nullptr; + QCheckBox *useThresholdFlamegraph = nullptr; + + // Overview + QCheckBox *useBorderOverview = nullptr; + + // Misc + QCheckBox *colorCodingTimeRecords = nullptr; + QCheckBox *absoluteDurationsForSliders = nullptr; + QCheckBox *useREGSliderForOV = nullptr; +}; + + +#endif //MOTIV_SETTINGSPOPUP_HPP diff --git a/src/utils.cpp b/src/utils.cpp index ed413dc..96b6aaa 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -1,6 +1,6 @@ /* * Marvelous OTF2 Traces Interactive Visualizer (MOTIV) - * Copyright (C) 2023 Florian Gallrein, Björn Gehrke + * Copyright (C) 2023 Florian Gallrein, Björn Gehrke, Jessica Lafontaine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/stats b/stats/stats similarity index 85% rename from stats rename to stats/stats index 84a38c3..82799a5 100755 --- a/stats +++ b/stats/stats @@ -1,8 +1,30 @@ #!/bin/bash - -# *** constants *** -CFG_LOCATION=/home/$(whoami)/.config/stats.cfg +# Marvelous OTF2 Traces Interactive Visualizer (MOTIV) +# Copyright (C) 2023 Tomas Cirkov +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program 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 for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + + +# *** positions & constants *** +SCRIPT_LOCATION=$(realpath "$0") +WORK_LOCATION=$(dirname "$SCRIPT_LOCATION") +MOTIV_LOCATION=$(dirname "$WORK_LOCATION") +CFG_LOCATION=$WORK_LOCATION/stats.cfg +BIN_LOCATION=$(find "$MOTIV_LOCATION" -type f -name "motiv" -exec readlink -f {} \;) +GIT_AVAILABLE=true; DATE_FORMAT="%Y-%m-%d@%H-%M-%S" RED=`tput setaf 1` GREEN=`tput setaf 2` @@ -23,7 +45,7 @@ NOFORMAT=`tput sgr0` LINEFRAMES=(" / " " ‒ " " \\ " " | ") DOTFRAMES=("working " "working. " "working.. " "working...") CALIBRATION_QUESTION_1="[1/6] Do you wish to run ${CYAN}${BOLD}memory tests${NOFORMAT} via smem? (${BOLD}${GREEN}Y${NOFORMAT}/${BOLD}${RED}N${NOFORMAT})" -CALIBRATION_QUESTION_2="[2/6] How many seconds shall stats ${CYAN}${BOLD}wait${NOFORMAT} between a motiv startup and the RAM sampling via smem?" +CALIBRATION_QUESTION_2="[2/6] How many seconds shall stats ${CYAN}${BOLD}wait${NOFORMAT} between a motiv start and the RAM sampling via smem?" CALIBRATION_QUESTION_3="[3/6] How many ${CYAN}${BOLD}decimal places${NOFORMAT} after the decimal point (precision) are required?" CALIBRATION_QUESTION_4="[4/6] Do you want to ${CYAN}${BOLD}print debug information${NOFORMAT} (only for time tests) to the terminal? (${BOLD}${GREEN}Y${NOFORMAT}/${BOLD}${RED}N${NOFORMAT})" CALIBRATION_QUESTION_5="[5/6] How many ${CYAN}${BOLD}data triplets${NOFORMAT} like <%h%v%u%...> does a -run produce?" @@ -38,8 +60,8 @@ trap 'error_line ${LINENO}' ERR # we probably don't want to keep logs from situations like "ctrl+c"-ed runs clean_up_full() { exitcode=$? - if [ -f "tmpfile@$file_name" ] && [ "$memory" = "1" ]; then - rm tmpfile@$file_name + if [ -f "$WORK_LOCATION/tmpfile@$file_name" ] && [ "$memory" = "1" ]; then + rm $WORK_LOCATION/tmpfile@$file_name fi if [ -f "$file_name" ] && [ "$dbg_info" = "0" ] && [ "$exitcode" -gt 0 ]; then rm $file_name @@ -56,7 +78,7 @@ trap 'clean_up_full' EXIT if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then clear echo "*******************************************************************************" - echo "*** ${CYAN}-h --help${NOFORMAT} <=> shows legal arguments for 'stats' ***" + echo "*** ${CYAN}-h --help${NOFORMAT} <=> shows legal arguments for 'stats' ***" echo "*** ${CYAN}-c --calibration${NOFORMAT} <=> interactive calibration of 'stats' ***" echo "*** -> Do we need debug-prints? ***" echo "*** -> How precise does our calc. has to be? ***" @@ -112,8 +134,8 @@ dbg_info=1 dbg_log="" # how many >>%h%v%u%<< do we have? triplet_count=2 -# where do we want to save the results? ("" <=> same dir as stats) -res_path="" +# where do we want to save the results? (default choice: same dir as stats) +res_path=$WORK_LOCATION # how many arguments do we have? argc=$# # how many samples do we want? (first argument) @@ -181,8 +203,8 @@ read_all_nonflag_params() { fi if [ -n "$res_path_new" ]; then if [ "$res_path_new" == "\"\"" ] ; then - # "" means, we want to save the results to the same directory as stats - res_path="" + # "" means, we want to save the results to default choice + res_path=$WORK_LOCATION else if [ -d "$res_path_new" ]; then res_path=$res_path_new @@ -237,7 +259,7 @@ if [ "$1" = "-c" ] || [ "$1" = "--calibration" ]; then conditional_clear if ! [ -f "$CFG_LOCATION" ]; then echo -e "${YELLOW}${BOLD}Info${NOFORMAT}: could not find the config file ${CFG_LOCATION} for stats, will create a default config..." - echo -e "# do we want to measure memory use? (0 <=> no)\nmemory=0\n# how many seconds have to pass between the start of motiv and the memory snapshot via smem?\ngrace_period=2\n# amount of decimal places after the decimal point\nprecision=3\n# do we want to see debug information? (0 <=> no)\ndbg_info=0\n# how many >>%h%v%u%<< do we have?\ntriplet_count=2\n# where do we want to save the results? ("" <=> same dir as stats)\nres_path=\"\"" >> $CFG_LOCATION + echo -e "# do we want to measure memory use? (0 <=> no)\nmemory=0\n# how many seconds have to pass between the start of motiv and the memory snapshot via smem?\ngrace_period=2\n# amount of decimal places after the decimal point\nprecision=3\n# do we want to see debug information? (0 <=> no)\ndbg_info=0\n# how many data "units" does a -run produce? (1.0.0 has no stats support; version 1.0.1 up to at least 2.1.1 => 2)\ntriplet_count=2\n# where do we want to save the results? (\"\" <=> default choice: same dir as stats)\nres_path=\"\"" >> $CFG_LOCATION echo -e "[-/6] Do you wish to proceed with the calibration of the newly created ? (${BOLD}${GREEN}Y${NOFORMAT}/${BOLD}${RED}N${NOFORMAT})" echo "" read -p "" -n 1 answer1 @@ -303,7 +325,7 @@ if [ "$1" = "-c" ] || [ "$1" = "--calibration" ]; then conditional_clear echo "" while true; do - echo -e "$CALIBRATION_QUESTION_5\n -> Example (too small): %h1%v1%u1%%h2%v2%u2%%h3%v3%u3% with the value 2 is going to make stats to collect the data for %h1...% up until only %h2...%\n -> Hint: stats will simply crash if the value is too big" + echo -e "$CALIBRATION_QUESTION_5\n -> Example: %MainWindow::loadTrace()%4%ms%%application in general%73%ms%%\n -> Hint: the default value for Motiv is 2\n -> Hint: too small => stats will ignore some data; too big => stats will crash" echo "" read -p "Answer: " answer5 if test $answer5 -ge 1 ; then @@ -351,10 +373,27 @@ else # we have a regular stats run check_config read_all_nonflag_params - check_smem + if [ "$memory" -ne 0 ]; then + check_smem + fi fi # *** basic crital errors *** +# multiple binaries +if [ "$(echo "$BIN_LOCATION" | wc -l)" -gt 1 ] 2> /dev/null; then + conditional_clear + echo "${BG_RED}${BOLD}Critical${NOFORMAT}: multiple motiv binaries within the motiv dir, unclear how to proceed..." + echo " -> locations: "$BIN_LOCATION + echo " -> more details via -h/--help" + exit 1 +fi +# can't find motiv +if ! [ -f "$BIN_LOCATION" ] 2> /dev/null; then + conditional_clear + echo "${BG_RED}${BOLD}Critical${NOFORMAT}: can't find motiv, expected in: "$BIN_LOCATION + echo " -> more details via -h/--help" + exit 1 +fi # FAQ: Q1 # no sample size if ! [ "$count" -gt 0 ] 2> /dev/null; then @@ -473,7 +512,7 @@ do fi # we collect the raw data - output_time=$(time (./build/motiv -t $cur_path 2>/dev/null) 2>&1) + output_time=$(time ($BIN_LOCATION -t $cur_path 2>/dev/null) 2>&1) # that's the array pattern: e(mpty) h(int) v(value) u(unit), e h v u ... time values (user, real, sys) # FAQ: Q4 @@ -485,11 +524,11 @@ do # RAM usage review if [ "$memory" -ne 0 ]; then - ./build/motiv $cur_path 2>> tmpfile@$file_name & + $BIN_LOCATION $cur_path 2>> $WORK_LOCATION/tmpfile@$file_name & prog_pid=$! sleep 2 while true; do - if grep -q "motiv ready" tmpfile@$file_name; then + if grep -q "motiv ready" $WORK_LOCATION/tmpfile@$file_name; then break fi done @@ -539,7 +578,7 @@ do else conditional_clear if [ $val_pos -gt ${#ehvu_array[@]} ]; then - echo "${BG_RED}${BOLD}Critical${NOFORMAT}: out of bound regarding the value array, please check wether in corresponds to the true amount of %h%v%u%-data triplets produced via <./motiv -t [trace]>-runs" + echo "${BG_RED}${BOLD}Critical${NOFORMAT}: out of bound regarding the value array, please check wether in $CFG_LOCATION corresponds to the true amount of %h%v%u%-data triplets produced via <./motiv -t [trace]>-runs" else echo "${BG_RED}${BOLD}Critical${NOFORMAT}: unkown time unit <${RED}${ehvu_array[$(($val_pos+1))]}${NOFORMAT}>, that happend for the ${j}. trace in the ${p}. iteration for the ${q}. sum/metric <${BG_YELLOW}${BOLD}${ehvu_array[$(($val_pos-1))]}${NOFORMAT}>" fi @@ -628,29 +667,43 @@ done # *** context-information *** -if [ -n "$(whereis -b git | cut -d ' ' -f 2)" ]; then - git fetch - git_info="\nGIT\nRepo URL:\t"$(git remote get-url origin) +if [ "$GIT_AVAILABLE" = true ]; then + no_errors=true; + git_info="\nGIT\n" + if ! [ -n "$(whereis -b git | cut -d ' ' -f 2)" ]; then + git_info="\ncan't find git\n!" + no_errors=false; + fi + if ! [ -d "$MOTIV_LOCATION/.git" ]; then + git_info="\ncan't find .git in "$MOTIV_LOCATION"\n" + no_errors=false; + fi + if [ "$no_errors" = true ]; then + git -C $MOTIV_LOCATION fetch + git_info=$git_info"Repo URL:\t\t"$(git -C $MOTIV_LOCATION remote get-url origin) - # what branch do we test? - git_branch=$(git branch --show-current) - git_info=$git_info"\nBranch:\t\t"$git_branch + # what branch do we test? + git_branch=$(git -C $MOTIV_LOCATION branch --show-current) + git_info=$git_info"\n\nBranch:\t\t\t"$git_branch"\n" - # documentation of the development status + # documentation of the development status - # we assume that $(git rev-parse HEAD) represents the current used revision - git_local_commit_hash=$(git rev-parse HEAD) + # we assume that $(git rev-parse HEAD) represents the current used revision + git_local_commit_hash=$(git -C $MOTIV_LOCATION rev-parse HEAD) - # do we have any changes relative to the most recent branch commit? - git_info=$git_info"\n\t\t-> any difference to the latest commit?\n"$git_last_commit$(git diff --stat $git_branch | sed 's/ /\t\t/') + # do we have any changes relative to the most recent branch commit? + git_info=$git_info"\n\t\t-> any difference to the latest commit?\n"$git_last_commit$(git -C $MOTIV_LOCATION diff --stat $git_branch | sed 's/ /\t\t/') - git_info=$git_info"\n\nHEAD (Hash):\t"$git_local_commit_hash - # do we have any changes relative to the used "version" of our branch? - git_info=$git_info"\n\t\t-> any difference to the used revision?\n"$(git diff --stat $git_local_commit_hash | sed 's/ /\t\t/') + git_info=$git_info"\n\nHEAD (Hash):\t"$git_local_commit_hash + # do we have any changes relative to the used "version" of our branch? + git_info=$git_info"\n\n\t\t-> any difference to the used revision?\n"$(git -C $MOTIV_LOCATION diff --stat $git_local_commit_hash | sed 's/ /\t\t/') + fi fi echo -e "\n\n\n" >> $path_plus_file_name echo -e "***************************\n*** context information ***\n***************************" >> $path_plus_file_name +echo -e "\n"$($BIN_LOCATION --version) >> $path_plus_file_name +echo -e $git_info >> $path_plus_file_name echo -e "\nOS\n"$(uname -a) >> $path_plus_file_name echo -e "\nCPU\n"$(lscpu | grep "Model name:" | sed -r 's/Model name:\s{1,}//g') >> $path_plus_file_name # this is an alternative to echo, the upside is that we can keep the format of $(free -h) @@ -659,17 +712,15 @@ cat <> $path_plus_file_name RAM $(free -h) EOF -echo -e "\nSAMPLE SIZE\n"$count"#" >> $path_plus_file_name -echo -e $git_info >> $path_plus_file_name -echo -e "\nSAMPLE-LOG\n"$log >> $path_plus_file_name +echo -e "\nSAMPLE-LOG\nSample size:\t"$count"# (measurements per tracefile)\n"$log >> $path_plus_file_name # *** final exit *** conditional_clear echo "${BOLD}stats${NOFORMAT}: ${BG_CYAN}${path_plus_file_name}${NOFORMAT}" # small clean up if [ "$memory" = "1" ]; then - rm tmpfile@$file_name + rm $WORK_LOCATION/tmpfile@$file_name fi exit 0 @@ -677,7 +728,7 @@ exit 0 # *** FAQ *** # Q1: Why not test against <$#> (rather than <$argc>), if we have enough traces? -# A1: *Both* will variables will change throughout the script, but with a different meaning: <$#> will be always changed via up until zero, when we prepare the trace-paths. On the other hand <$argc> will be changed only *and if only* when we discard some paths as unusable! +# A1: *Both* variables will change throughout the script, but with a different meaning: <$#> will be always changed via up until zero, when we prepare the trace-paths. On the other hand <$argc> will be changed only *and if only* when we discard some paths as unusable! # Q2: Why not test against <$1> (rather than <$count>) if we have a plausible sample size? # A2: That's a similar situation to Q., <$1> will change it's meaning, while <$count> is a constant and really represents our sample size, <$1> is just the initial way how we get it! diff --git a/stats/stats.cfg b/stats/stats.cfg new file mode 100644 index 0000000..7a36a5e --- /dev/null +++ b/stats/stats.cfg @@ -0,0 +1,12 @@ +# do we want to measure memory use? (0 <=> no) +memory=0 +# how many seconds have to pass between the start of motiv and the memory snapshot via smem? +grace_period=2 +# amount of decimal places after the decimal point +precision=3 +# do we want to see debug information? (0 <=> no) +dbg_info=0 +# how many data "units" does a -run produce? (1.0.0 has no stats support; version 1.0.1 up to at least 2.1.1 => 2) +triplet_count=2 +# where do we want to save the results? ("" <=> same dir as stats) +res_path="" diff --git a/test_selection/Large_Score-P/scorep.cfg b/test_selection/Large_Score-P/scorep.cfg new file mode 100755 index 0000000..4629e9a --- /dev/null +++ b/test_selection/Large_Score-P/scorep.cfg @@ -0,0 +1,35 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=52428800 +SCOREP_PAGE_SIZE=8192 +SCOREP_EXPERIMENT_DIRECTORY='scorep_wrf_8_part_instr_trace_filter_metric_exclusive2' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_EXECUTABLE='' +SCOREP_PROFILING_TASK_TABLE_SIZE=64 +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='none','cube4' +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_NLOCATIONS_PER_SION_FILE=1024 +SCOREP_TRACING_COMPRESS=false +SCOREP_ONLINEACCESS_ENABLE=false +SCOREP_ONLINEACCESS_REG_PORT=50100 +SCOREP_ONLINEACCESS_REG_HOST='localhost' +SCOREP_ONLINEACCESS_BASE_PORT=50010 +SCOREP_ONLINEACCESS_APPL_NAME='appl' +SCOREP_FILTERING_FILE='/fastfs/tschuet/scorep.filt' +SCOREP_METRIC_PAPI='PAPI_L2_TCM,PAPI_TLB_DM,PAPI_BR_MSP,PAPI_FP_OPS' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_SELECTIVE_CONFIG_FILE='' +SCOREP_MPI_HIERARCHICAL_UNIFY=true +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_ACCESS_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS= +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/Large_Score-P/scorep.filt b/test_selection/Large_Score-P/scorep.filt new file mode 100755 index 0000000..a9d5c7b --- /dev/null +++ b/test_selection/Large_Score-P/scorep.filt @@ -0,0 +1,27 @@ +SCOREP_FILE_NAMES_BEGIN # This is a comment + EXCLUDE */external/* + EXCLUDE */frame/* + EXCLUDE */share/* + EXCLUDE */tools/* +SCOREP_FILE_NAMES_END + +SCOREP_REGION_NAMES_BEGIN + EXCLUDE MPI_Comm_rank + EXCLUDE vspow_ + EXCLUDE seccmp_ + EXCLUDE normalize_basetime_ + EXCLUDE buffer_for_proc + EXCLUDE nfeb_ + EXCLUDE esmf_basetimemod_mp_esmf_basetimesum_ + EXCLUDE esmf_basetimemod_mp_esmf_basetimege_ + EXCLUDE ndaysinyear_ + EXCLUDE nsecondsinyear_ + EXCLUDE esmf_basetimemod_mp_esmf_basetimedifference_ + EXCLUDE buffer_size_for_proc + EXCLUDE f_pack_int_ + EXCLUDE f_unpack_int_ + EXCLUDE f_unpack_int_ikj_ + EXCLUDE f_pack_int_ikj_ + EXCLUDE task_for_point_ + EXCLUDE rsl_lite_pack_period_ +SCOREP_REGION_NAMES_END diff --git a/test_selection/Large_Score-P/traces.def b/test_selection/Large_Score-P/traces.def new file mode 100755 index 0000000..f8c8c3b Binary files /dev/null and b/test_selection/Large_Score-P/traces.def differ diff --git a/test_selection/Large_Score-P/traces.otf2 b/test_selection/Large_Score-P/traces.otf2 new file mode 100755 index 0000000..5b12c2e Binary files /dev/null and b/test_selection/Large_Score-P/traces.otf2 differ diff --git a/test_selection/Large_Score-P/traces/0.def b/test_selection/Large_Score-P/traces/0.def new file mode 100755 index 0000000..197cecb Binary files /dev/null and b/test_selection/Large_Score-P/traces/0.def differ diff --git a/test_selection/Large_Score-P/traces/0.evt b/test_selection/Large_Score-P/traces/0.evt new file mode 100755 index 0000000..f4df396 Binary files /dev/null and b/test_selection/Large_Score-P/traces/0.evt differ diff --git a/test_selection/Large_Score-P/traces/1.def b/test_selection/Large_Score-P/traces/1.def new file mode 100755 index 0000000..ae7c877 Binary files /dev/null and b/test_selection/Large_Score-P/traces/1.def differ diff --git a/test_selection/Large_Score-P/traces/1.evt b/test_selection/Large_Score-P/traces/1.evt new file mode 100755 index 0000000..d764f17 Binary files /dev/null and b/test_selection/Large_Score-P/traces/1.evt differ diff --git a/test_selection/Large_Score-P/traces/2.def b/test_selection/Large_Score-P/traces/2.def new file mode 100755 index 0000000..fa07ece Binary files /dev/null and b/test_selection/Large_Score-P/traces/2.def differ diff --git a/test_selection/Large_Score-P/traces/2.evt b/test_selection/Large_Score-P/traces/2.evt new file mode 100755 index 0000000..d4a2131 Binary files /dev/null and b/test_selection/Large_Score-P/traces/2.evt differ diff --git a/test_selection/Large_Score-P/traces/3.def b/test_selection/Large_Score-P/traces/3.def new file mode 100755 index 0000000..731af28 Binary files /dev/null and b/test_selection/Large_Score-P/traces/3.def differ diff --git a/test_selection/Large_Score-P/traces/3.evt b/test_selection/Large_Score-P/traces/3.evt new file mode 100755 index 0000000..88e4ecf Binary files /dev/null and b/test_selection/Large_Score-P/traces/3.evt differ diff --git a/test_selection/Large_Score-P/traces/4.def b/test_selection/Large_Score-P/traces/4.def new file mode 100755 index 0000000..663e335 Binary files /dev/null and b/test_selection/Large_Score-P/traces/4.def differ diff --git a/test_selection/Large_Score-P/traces/4.evt b/test_selection/Large_Score-P/traces/4.evt new file mode 100755 index 0000000..c2e1408 Binary files /dev/null and b/test_selection/Large_Score-P/traces/4.evt differ diff --git a/test_selection/Large_Score-P/traces/5.def b/test_selection/Large_Score-P/traces/5.def new file mode 100755 index 0000000..30dbfcc Binary files /dev/null and b/test_selection/Large_Score-P/traces/5.def differ diff --git a/test_selection/Large_Score-P/traces/5.evt b/test_selection/Large_Score-P/traces/5.evt new file mode 100755 index 0000000..d95095e Binary files /dev/null and b/test_selection/Large_Score-P/traces/5.evt differ diff --git a/test_selection/Large_Score-P/traces/6.def b/test_selection/Large_Score-P/traces/6.def new file mode 100755 index 0000000..959f841 Binary files /dev/null and b/test_selection/Large_Score-P/traces/6.def differ diff --git a/test_selection/Large_Score-P/traces/6.evt b/test_selection/Large_Score-P/traces/6.evt new file mode 100755 index 0000000..7a065e3 Binary files /dev/null and b/test_selection/Large_Score-P/traces/6.evt differ diff --git a/test_selection/Large_Score-P/traces/7.def b/test_selection/Large_Score-P/traces/7.def new file mode 100755 index 0000000..27fe7f9 Binary files /dev/null and b/test_selection/Large_Score-P/traces/7.def differ diff --git a/test_selection/Large_Score-P/traces/7.evt b/test_selection/Large_Score-P/traces/7.evt new file mode 100755 index 0000000..47f6059 Binary files /dev/null and b/test_selection/Large_Score-P/traces/7.evt differ diff --git a/test_selection/absolute_minimal_trace/bin9/bin9 b/test_selection/absolute_minimal_trace/bin9/bin9 new file mode 100755 index 0000000..e53d9f1 Binary files /dev/null and b/test_selection/absolute_minimal_trace/bin9/bin9 differ diff --git a/test_selection/absolute_minimal_trace/bin9/bin9.c b/test_selection/absolute_minimal_trace/bin9/bin9.c new file mode 100755 index 0000000..a43eeed --- /dev/null +++ b/test_selection/absolute_minimal_trace/bin9/bin9.c @@ -0,0 +1,5 @@ +int main() +{ + return 0; +} + diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/MANIFEST.md b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/profile.cubex b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/profile.cubex new file mode 100644 index 0000000..ebcc8f4 Binary files /dev/null and b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/profile.cubex differ diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/scorep.cfg b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.def b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.def new file mode 100644 index 0000000..4e40210 Binary files /dev/null and b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.def differ diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.otf2 b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.otf2 new file mode 100644 index 0000000..1b0c851 Binary files /dev/null and b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces.otf2 differ diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.def b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.def new file mode 100644 index 0000000..4e6f2bc Binary files /dev/null and b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.def differ diff --git a/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.evt b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.evt new file mode 100644 index 0000000..26fe2c4 Binary files /dev/null and b/test_selection/absolute_minimal_trace/scorep-20230904_1531_40061700325867/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/README.md b/test_selection/dorsal-lab_testcases/README.md new file mode 100755 index 0000000..c532163 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/README.md @@ -0,0 +1,21 @@ +# Examples of OTF2 and converted CTF traces +This repository contains examples of OTF2 traces and the resulting CTF traces after conversion with the OTF2 to CTF converter available [here](https://github.com/dorsal-lab/OTF2-to-CTF-converter) +The codes for the examples have been found on [CodinGame](https://www.codingame.com) and [RookieHPC](https://www.rookiehpc.com/) and are available in the ```src``` directory. +The resulting traces are in the ```traces``` directory, there are 5 differents programs and corresponding traces: +- One program with 2 ranks and a Mpi_Bsend/Recv routine +- One program with 2 ranks and a Mpi_Ssend/Irecv routine +- One program with 4 ranks and a Mpi_Gather routine +- One program with 8 ranks : 2 communicators are created and an allreduce operation is called in both of them +- One program with 4 ranks on 2 remote nodes. Each rank create 2 additional threads calling a "Hello world" function. + +All the files generated with Score-P are present in each trace, but only the ```traces.otf2```, ```traces.def``` files and ```traces``` directory are required to do the conversion to CTF. The resulting CTF traces are in the ```converted_otf2_``` directory. + +# How to regenerate the traces +To regenerate the traces you need [Score-P](https://perftools.pages.jsc.fz-juelich.de/cicd/scorep/tags/scorep-7.0/html/index.html) and [OTF2](http://perftools.pages.jsc.fz-juelich.de/cicd/otf2/tags/otf2-2.3/otf2-2.3.tar.gz). +You need to compile the code with Score-P as you would with mpicc : ```scorep mpicc my_program.c -o my_program``` +Then you set the following environment variable : ```export SCOREP_ENABLE_TRACING=1``` +You run the program : ```mpirun -n my_program``` +It will generate a trace directory containing a ```traces.otf2``` file. +If you want the converted CTF trace you have to set ```OTF2_CONVERTER=``` and convert the trace ```/otf2_converter traces.otf2``` +For the program running with pthread you need to add -lpthread at build step. + diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/MANIFEST.md b/test_selection/dorsal-lab_testcases/mpi_allreduce/MANIFEST.md new file mode 100755 index 0000000..0918bda --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_allreduce/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/0 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/0 new file mode 100755 index 0000000..6c8e192 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/0 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/1 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/1 new file mode 100755 index 0000000..22f7ec5 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/1 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/2 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/2 new file mode 100755 index 0000000..8dbf918 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/3 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/3 new file mode 100755 index 0000000..1e5ca3d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/3 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/4 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/4 new file mode 100755 index 0000000..8a71f3d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/4 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/5 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/5 new file mode 100755 index 0000000..a1f4f58 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/5 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/6 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/6 new file mode 100755 index 0000000..d15be39 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/6 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/7 b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/7 new file mode 100755 index 0000000..68c5f94 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/7 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/global_def b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/global_def new file mode 100755 index 0000000..1c19605 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/global_def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/metadata b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/metadata new file mode 100755 index 0000000..ada01bb --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_allreduce/converted_otf2_26372_1641396411/metadata @@ -0,0 +1,4752 @@ +/* CTF 1.8 */ + +/* + * The MIT License (MIT) + * + * Copyright (c) 2015-2020 Philippe Proulx + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * + * The following code was generated by barectf v3.0.1 + * on 2021-12-23T15:22:42.642623. + * + * For more details, see . + */ + +trace { + major = 1; + minor = 8; + byte_order = le; + packet.header := struct { + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } magic; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } stream_id; + } align(8); +}; + +env { + domain = "bare"; + tracer_name = "otf2"; + tracer_major = 3; + tracer_minor = 0; + tracer_patch = 1; + tracer_pre = ""; + barectf_gen_date = "2021-12-23T15:22:42.642623"; +}; + +clock { + name = default; + freq = 3293841647; + precision = 0; + offset_s = 1641387136; + offset = 958208802; + absolute = false; +}; + +/* Data stream type `default` */ +stream { + id = 0; + packet.context := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } packet_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } content_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_begin; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_end; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } events_discarded; + } align(8); + event.header := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } id; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp; + } align(8); +}; + +event { + stream_id = 0; + id = 0; + name = "EventAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 1; + name = "EventAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 2; + name = "EventAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 3; + name = "EventAttribute_Double"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 4; + name = "EventAttribute_Float"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 5; + name = "EventAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 6; + name = "EventAttribute_Int16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 7; + name = "EventAttribute_Int32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 8; + name = "EventAttribute_Int64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 9; + name = "EventAttribute_Int8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 10; + name = "EventAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 11; + name = "EventAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 12; + name = "EventAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 13; + name = "EventAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 14; + name = "EventAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 15; + name = "EventAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 16; + name = "EventAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 17; + name = "EventAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 18; + name = "EventAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 19; + name = "EventAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 20; + name = "EventAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 21; + name = "EventAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 22; + name = "EventAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 23; + name = "EventAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 24; + name = "Event_BufferFlush"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } stopTime; + } align(1); +}; + +event { + stream_id = 0; + id = 25; + name = "Event_CallingContextEnter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + } align(1); +}; + +event { + stream_id = 0; + id = 26; + name = "Event_CallingContextLeave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + } align(1); +}; + +event { + stream_id = 0; + id = 27; + name = "Event_CallingContextSample"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } interruptGenerator; + } align(1); +}; + +event { + stream_id = 0; + id = 28; + name = "Event_Enter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 29; + name = "Event_IoAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 30; + name = "Event_IoChangeStatusFlags"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 31; + name = "Event_IoCreateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creationFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 32; + name = "Event_IoDeleteFile"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + } align(1); +}; + +event { + stream_id = 0; + id = 33; + name = "Event_IoDestroyHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + } align(1); +}; + +event { + stream_id = 0; + id = 34; + name = "Event_IoDuplicateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } oldHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } newHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 35; + name = "Event_IoOperationBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } operationFlags; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesRequest; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 36; + name = "Event_IoOperationCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 37; + name = "Event_IoOperationComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesResult; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 38; + name = "Event_IoOperationIssued"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 39; + name = "Event_IoOperationTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 40; + name = "Event_IoReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 41; + name = "Event_IoSeek"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetRequest; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } whence; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetResult; + } align(1); +}; + +event { + stream_id = 0; + id = 42; + name = "Event_IoTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 43; + name = "Event_Leave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 44; + name = "Event_MeasurementOnOff"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } measurementMode; + } align(1); +}; + +event { + stream_id = 0; + id = 45; + name = "Event_Metric"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfMetrics; + } align(1); +}; + +event { + stream_id = 0; + id = 46; + name = "Event_MpiCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 47; + name = "Event_MpiCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 48; + name = "Event_MpiIrecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 49; + name = "Event_MpiIrecvRequest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 50; + name = "Event_MpiIsend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 51; + name = "Event_MpiIsendComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 52; + name = "Event_MpiRecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 53; + name = "Event_MpiRequestCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 54; + name = "Event_MpiRequestTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 55; + name = "Event_MpiSend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 56; + name = "Event_OmpAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 57; + name = "Event_OmpFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfRequestedThreads; + } align(1); +}; + +event { + stream_id = 0; + id = 58; + name = "Event_OmpJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 59; + name = "Event_OmpReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 60; + name = "Event_OmpTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 61; + name = "Event_OmpTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 62; + name = "Event_OmpTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 63; + name = "Event_ParameterInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 64; + name = "Event_ParameterString"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } stringID; + } align(1); +}; + +event { + stream_id = 0; + id = 65; + name = "Event_ParameterUnsignedInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 66; + name = "Event_ProgramArgument"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programArgument; + } align(1); +}; + +event { + stream_id = 0; + id = 67; + name = "Event_ProgramBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programName; + } align(1); +}; + +event { + stream_id = 0; + id = 68; + name = "Event_ProgramEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exitStatus; + } align(1); +}; + +event { + stream_id = 0; + id = 69; + name = "Event_RmaAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 70; + name = "Event_RmaAtomic"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 71; + name = "Event_RmaCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 72; + name = "Event_RmaCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 73; + name = "Event_RmaGet"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 74; + name = "Event_RmaGroupSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + } align(1); +}; + +event { + stream_id = 0; + id = 75; + name = "Event_RmaOpCompleteBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 76; + name = "Event_RmaOpCompleteNonBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 77; + name = "Event_RmaOpCompleteRemote"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 78; + name = "Event_RmaOpTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 79; + name = "Event_RmaPut"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 80; + name = "Event_RmaReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + } align(1); +}; + +event { + stream_id = 0; + id = 81; + name = "Event_RmaRequestLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 82; + name = "Event_RmaSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } syncType; + } align(1); +}; + +event { + stream_id = 0; + id = 83; + name = "Event_RmaTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 84; + name = "Event_RmaWaitChange"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 85; + name = "Event_RmaWinCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 86; + name = "Event_RmaWinDestroy"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 87; + name = "Event_ThreadAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 88; + name = "Event_ThreadBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 89; + name = "Event_ThreadCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 90; + name = "Event_ThreadEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 91; + name = "Event_ThreadFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } matchnumberOfRequestedThreadsingId; + } align(1); +}; + +event { + stream_id = 0; + id = 92; + name = "Event_ThreadJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + } align(1); +}; + +event { + stream_id = 0; + id = 93; + name = "Event_ThreadReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 94; + name = "Event_ThreadTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 95; + name = "Event_ThreadTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 96; + name = "Event_ThreadTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 97; + name = "Event_ThreadTeamBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 98; + name = "Event_ThreadTeamEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 99; + name = "Event_ThreadWait"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 100; + name = "GlobalDefAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 101; + name = "GlobalDefAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 102; + name = "GlobalDefAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 103; + name = "GlobalDefAttribute_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 104; + name = "GlobalDefAttribute_Float"; + fields := struct { + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 105; + name = "GlobalDefAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 106; + name = "GlobalDefAttribute_Int16"; + fields := struct { + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 107; + name = "GlobalDefAttribute_Int32"; + fields := struct { + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 108; + name = "GlobalDefAttribute_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 109; + name = "GlobalDefAttribute_Int8"; + fields := struct { + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 110; + name = "GlobalDefAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 111; + name = "GlobalDefAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 112; + name = "GlobalDefAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 113; + name = "GlobalDefAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 114; + name = "GlobalDefAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 115; + name = "GlobalDefAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 116; + name = "GlobalDefAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 117; + name = "GlobalDefAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 118; + name = "GlobalDefAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 119; + name = "GlobalDefAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 120; + name = "GlobalDefAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 121; + name = "GlobalDefAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 122; + name = "GlobalDefAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 123; + name = "GlobalDefAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 124; + name = "GlobalDef_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + } align(1); +}; + +event { + stream_id = 0; + id = 125; + name = "GlobalDef_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceCodeLocation; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 126; + name = "GlobalDef_CallingContextProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 127; + name = "GlobalDef_Callpath"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 128; + name = "GlobalDef_CallpathParameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callpath; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + } align(1); +}; + +event { + stream_id = 0; + id = 129; + name = "GlobalDef_Callsite"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } enteredRegion; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } leftRegion; + } align(1); +}; + +event { + stream_id = 0; + id = 130; + name = "GlobalDef_CartCoordinate"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartTopology; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __coordinates_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } coordinates[__coordinates_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 131; + name = "GlobalDef_CartDimension"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } size; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } cartPeriodicity; + } align(1); +}; + +event { + stream_id = 0; + id = 132; + name = "GlobalDef_CartTopology"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __cartDimensions_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartDimensions[__cartDimensions_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 133; + name = "GlobalDef_ClockProperties"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } timerResolution; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } globalOffset; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } traceLength; + } align(1); +}; + +event { + stream_id = 0; + id = 134; + name = "GlobalDef_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 135; + name = "GlobalDef_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } groupType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } groupFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfMembers; + } align(1); +}; + +event { + stream_id = 0; + id = 136; + name = "GlobalDef_GroupMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + } align(1); +}; + +event { + stream_id = 0; + id = 137; + name = "GlobalDef_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } interruptGeneratorMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } period; + } align(1); +}; + +event { + stream_id = 0; + id = 138; + name = "GlobalDef_IoDirectory"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 139; + name = "GlobalDef_IoFileProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 140; + name = "GlobalDef_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandleFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 141; + name = "GlobalDef_IoParadigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } identification; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmClass; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioParadigmFlags; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfProperties; + } align(1); +}; + +event { + stream_id = 0; + id = 142; + name = "GlobalDef_IoParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmProperty; + } align(1); +}; + +event { + stream_id = 0; + id = 143; + name = "GlobalDef_IoPreCreatedHandleState"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 144; + name = "GlobalDef_IoRegularFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 145; + name = "GlobalDef_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationType; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } numberOfEvents; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + } align(1); +}; + +event { + stream_id = 0; + id = 146; + name = "GlobalDef_LocationGroup"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationGroupType; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 147; + name = "GlobalDef_LocationGroupProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 148; + name = "GlobalDef_LocationProperty"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 149; + name = "GlobalDef_MetricClass"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __metricMembers_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricMembers[__metricMembers_len]; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricOccurrence; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } recorderKind; + } align(1); +}; + +event { + stream_id = 0; + id = 150; + name = "GlobalDef_MetricClassRecorder"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + } align(1); +}; + +event { + stream_id = 0; + id = 151; + name = "GlobalDef_MetricInstance"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricClass; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricScope; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 152; + name = "GlobalDef_MetricMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } valueType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unit; + } align(1); +}; + +event { + stream_id = 0; + id = 153; + name = "GlobalDef_Paradigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigmClass; + } align(1); +}; + +event { + stream_id = 0; + id = 154; + name = "GlobalDef_ParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } property; + } align(1); +}; + +event { + stream_id = 0; + id = 155; + name = "GlobalDef_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } parameterType; + } align(1); +}; + +event { + stream_id = 0; + id = 156; + name = "GlobalDef_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } canonicalName; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } regionRole; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } regionFlag; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } beginLineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } endLineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 157; + name = "GlobalDef_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + } align(1); +}; + +event { + stream_id = 0; + id = 158; + name = "GlobalDef_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 159; + name = "GlobalDef_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + string { + encoding = UTF8; + } stringValue; + } align(1); +}; + +event { + stream_id = 0; + id = 160; + name = "GlobalDef_SystemTreeNode"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } className; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 161; + name = "GlobalDef_SystemTreeNodeDomain"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } systemTreeDomain; + } align(1); +}; + +event { + stream_id = 0; + id = 162; + name = "GlobalDef_SystemTreeNodeProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 163; + name = "MetricValue_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 164; + name = "MetricValue_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 165; + name = "MetricValue_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/profile.cubex b/test_selection/dorsal-lab_testcases/mpi_allreduce/profile.cubex new file mode 100755 index 0000000..719f88c Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/profile.cubex differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/scorep.cfg b/test_selection/dorsal-lab_testcases/mpi_allreduce/scorep.cfg new file mode 100755 index 0000000..a5d33a5 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_allreduce/scorep.cfg @@ -0,0 +1,44 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.def new file mode 100755 index 0000000..38f0164 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.otf2 b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.otf2 new file mode 100755 index 0000000..58b1cd9 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces.otf2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.def new file mode 100755 index 0000000..2b9fe6c Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.evt new file mode 100755 index 0000000..33897f8 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.def new file mode 100755 index 0000000..f153d9f Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.evt new file mode 100755 index 0000000..a13d6ae Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/1.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.def new file mode 100755 index 0000000..22fa9dd Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.evt new file mode 100755 index 0000000..191fc96 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/2.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.def new file mode 100755 index 0000000..dba6256 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.evt new file mode 100755 index 0000000..43bcbf9 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/3.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.def new file mode 100755 index 0000000..845c7e9 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.evt new file mode 100755 index 0000000..a8ef45e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/4.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.def new file mode 100755 index 0000000..d145c0d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.evt new file mode 100755 index 0000000..48d072e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/5.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.def new file mode 100755 index 0000000..228166c Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.evt new file mode 100755 index 0000000..87bcc93 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/6.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.def b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.def new file mode 100755 index 0000000..3c57bd3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.evt b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.evt new file mode 100755 index 0000000..b96452f Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_allreduce/traces/7.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/MANIFEST.md b/test_selection/dorsal-lab_testcases/mpi_bsend/MANIFEST.md new file mode 100755 index 0000000..0918bda --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_bsend/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/0 b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/0 new file mode 100755 index 0000000..7d5318f Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/0 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/1 b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/1 new file mode 100755 index 0000000..542c4c0 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/1 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/global_def b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/global_def new file mode 100755 index 0000000..2e645f7 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/global_def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/metadata b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/metadata new file mode 100755 index 0000000..2731766 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_bsend/converted_otf2_26565_1641396516/metadata @@ -0,0 +1,4752 @@ +/* CTF 1.8 */ + +/* + * The MIT License (MIT) + * + * Copyright (c) 2015-2020 Philippe Proulx + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * + * The following code was generated by barectf v3.0.1 + * on 2021-12-23T15:22:42.642623. + * + * For more details, see . + */ + +trace { + major = 1; + minor = 8; + byte_order = le; + packet.header := struct { + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } magic; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } stream_id; + } align(8); +}; + +env { + domain = "bare"; + tracer_name = "otf2"; + tracer_major = 3; + tracer_minor = 0; + tracer_patch = 1; + tracer_pre = ""; + barectf_gen_date = "2021-12-23T15:22:42.642623"; +}; + +clock { + name = default; + freq = 3293834378; + precision = 0; + offset_s = 1641387136; + offset = 958208807; + absolute = false; +}; + +/* Data stream type `default` */ +stream { + id = 0; + packet.context := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } packet_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } content_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_begin; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_end; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } events_discarded; + } align(8); + event.header := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } id; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp; + } align(8); +}; + +event { + stream_id = 0; + id = 0; + name = "EventAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 1; + name = "EventAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 2; + name = "EventAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 3; + name = "EventAttribute_Double"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 4; + name = "EventAttribute_Float"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 5; + name = "EventAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 6; + name = "EventAttribute_Int16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 7; + name = "EventAttribute_Int32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 8; + name = "EventAttribute_Int64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 9; + name = "EventAttribute_Int8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 10; + name = "EventAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 11; + name = "EventAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 12; + name = "EventAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 13; + name = "EventAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 14; + name = "EventAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 15; + name = "EventAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 16; + name = "EventAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 17; + name = "EventAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 18; + name = "EventAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 19; + name = "EventAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 20; + name = "EventAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 21; + name = "EventAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 22; + name = "EventAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 23; + name = "EventAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 24; + name = "Event_BufferFlush"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } stopTime; + } align(1); +}; + +event { + stream_id = 0; + id = 25; + name = "Event_CallingContextEnter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + } align(1); +}; + +event { + stream_id = 0; + id = 26; + name = "Event_CallingContextLeave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + } align(1); +}; + +event { + stream_id = 0; + id = 27; + name = "Event_CallingContextSample"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } interruptGenerator; + } align(1); +}; + +event { + stream_id = 0; + id = 28; + name = "Event_Enter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 29; + name = "Event_IoAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 30; + name = "Event_IoChangeStatusFlags"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 31; + name = "Event_IoCreateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creationFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 32; + name = "Event_IoDeleteFile"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + } align(1); +}; + +event { + stream_id = 0; + id = 33; + name = "Event_IoDestroyHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + } align(1); +}; + +event { + stream_id = 0; + id = 34; + name = "Event_IoDuplicateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } oldHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } newHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 35; + name = "Event_IoOperationBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } operationFlags; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesRequest; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 36; + name = "Event_IoOperationCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 37; + name = "Event_IoOperationComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesResult; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 38; + name = "Event_IoOperationIssued"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 39; + name = "Event_IoOperationTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 40; + name = "Event_IoReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 41; + name = "Event_IoSeek"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetRequest; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } whence; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetResult; + } align(1); +}; + +event { + stream_id = 0; + id = 42; + name = "Event_IoTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 43; + name = "Event_Leave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 44; + name = "Event_MeasurementOnOff"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } measurementMode; + } align(1); +}; + +event { + stream_id = 0; + id = 45; + name = "Event_Metric"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfMetrics; + } align(1); +}; + +event { + stream_id = 0; + id = 46; + name = "Event_MpiCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 47; + name = "Event_MpiCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 48; + name = "Event_MpiIrecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 49; + name = "Event_MpiIrecvRequest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 50; + name = "Event_MpiIsend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 51; + name = "Event_MpiIsendComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 52; + name = "Event_MpiRecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 53; + name = "Event_MpiRequestCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 54; + name = "Event_MpiRequestTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 55; + name = "Event_MpiSend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 56; + name = "Event_OmpAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 57; + name = "Event_OmpFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfRequestedThreads; + } align(1); +}; + +event { + stream_id = 0; + id = 58; + name = "Event_OmpJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 59; + name = "Event_OmpReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 60; + name = "Event_OmpTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 61; + name = "Event_OmpTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 62; + name = "Event_OmpTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 63; + name = "Event_ParameterInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 64; + name = "Event_ParameterString"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } stringID; + } align(1); +}; + +event { + stream_id = 0; + id = 65; + name = "Event_ParameterUnsignedInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 66; + name = "Event_ProgramArgument"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programArgument; + } align(1); +}; + +event { + stream_id = 0; + id = 67; + name = "Event_ProgramBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programName; + } align(1); +}; + +event { + stream_id = 0; + id = 68; + name = "Event_ProgramEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exitStatus; + } align(1); +}; + +event { + stream_id = 0; + id = 69; + name = "Event_RmaAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 70; + name = "Event_RmaAtomic"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 71; + name = "Event_RmaCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 72; + name = "Event_RmaCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 73; + name = "Event_RmaGet"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 74; + name = "Event_RmaGroupSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + } align(1); +}; + +event { + stream_id = 0; + id = 75; + name = "Event_RmaOpCompleteBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 76; + name = "Event_RmaOpCompleteNonBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 77; + name = "Event_RmaOpCompleteRemote"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 78; + name = "Event_RmaOpTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 79; + name = "Event_RmaPut"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 80; + name = "Event_RmaReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + } align(1); +}; + +event { + stream_id = 0; + id = 81; + name = "Event_RmaRequestLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 82; + name = "Event_RmaSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } syncType; + } align(1); +}; + +event { + stream_id = 0; + id = 83; + name = "Event_RmaTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 84; + name = "Event_RmaWaitChange"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 85; + name = "Event_RmaWinCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 86; + name = "Event_RmaWinDestroy"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 87; + name = "Event_ThreadAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 88; + name = "Event_ThreadBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 89; + name = "Event_ThreadCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 90; + name = "Event_ThreadEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 91; + name = "Event_ThreadFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } matchnumberOfRequestedThreadsingId; + } align(1); +}; + +event { + stream_id = 0; + id = 92; + name = "Event_ThreadJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + } align(1); +}; + +event { + stream_id = 0; + id = 93; + name = "Event_ThreadReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 94; + name = "Event_ThreadTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 95; + name = "Event_ThreadTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 96; + name = "Event_ThreadTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 97; + name = "Event_ThreadTeamBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 98; + name = "Event_ThreadTeamEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 99; + name = "Event_ThreadWait"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 100; + name = "GlobalDefAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 101; + name = "GlobalDefAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 102; + name = "GlobalDefAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 103; + name = "GlobalDefAttribute_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 104; + name = "GlobalDefAttribute_Float"; + fields := struct { + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 105; + name = "GlobalDefAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 106; + name = "GlobalDefAttribute_Int16"; + fields := struct { + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 107; + name = "GlobalDefAttribute_Int32"; + fields := struct { + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 108; + name = "GlobalDefAttribute_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 109; + name = "GlobalDefAttribute_Int8"; + fields := struct { + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 110; + name = "GlobalDefAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 111; + name = "GlobalDefAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 112; + name = "GlobalDefAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 113; + name = "GlobalDefAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 114; + name = "GlobalDefAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 115; + name = "GlobalDefAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 116; + name = "GlobalDefAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 117; + name = "GlobalDefAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 118; + name = "GlobalDefAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 119; + name = "GlobalDefAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 120; + name = "GlobalDefAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 121; + name = "GlobalDefAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 122; + name = "GlobalDefAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 123; + name = "GlobalDefAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 124; + name = "GlobalDef_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + } align(1); +}; + +event { + stream_id = 0; + id = 125; + name = "GlobalDef_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceCodeLocation; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 126; + name = "GlobalDef_CallingContextProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 127; + name = "GlobalDef_Callpath"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 128; + name = "GlobalDef_CallpathParameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callpath; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + } align(1); +}; + +event { + stream_id = 0; + id = 129; + name = "GlobalDef_Callsite"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } enteredRegion; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } leftRegion; + } align(1); +}; + +event { + stream_id = 0; + id = 130; + name = "GlobalDef_CartCoordinate"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartTopology; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __coordinates_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } coordinates[__coordinates_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 131; + name = "GlobalDef_CartDimension"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } size; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } cartPeriodicity; + } align(1); +}; + +event { + stream_id = 0; + id = 132; + name = "GlobalDef_CartTopology"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __cartDimensions_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartDimensions[__cartDimensions_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 133; + name = "GlobalDef_ClockProperties"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } timerResolution; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } globalOffset; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } traceLength; + } align(1); +}; + +event { + stream_id = 0; + id = 134; + name = "GlobalDef_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 135; + name = "GlobalDef_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } groupType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } groupFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfMembers; + } align(1); +}; + +event { + stream_id = 0; + id = 136; + name = "GlobalDef_GroupMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + } align(1); +}; + +event { + stream_id = 0; + id = 137; + name = "GlobalDef_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } interruptGeneratorMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } period; + } align(1); +}; + +event { + stream_id = 0; + id = 138; + name = "GlobalDef_IoDirectory"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 139; + name = "GlobalDef_IoFileProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 140; + name = "GlobalDef_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandleFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 141; + name = "GlobalDef_IoParadigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } identification; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmClass; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioParadigmFlags; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfProperties; + } align(1); +}; + +event { + stream_id = 0; + id = 142; + name = "GlobalDef_IoParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmProperty; + } align(1); +}; + +event { + stream_id = 0; + id = 143; + name = "GlobalDef_IoPreCreatedHandleState"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 144; + name = "GlobalDef_IoRegularFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 145; + name = "GlobalDef_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationType; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } numberOfEvents; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + } align(1); +}; + +event { + stream_id = 0; + id = 146; + name = "GlobalDef_LocationGroup"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationGroupType; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 147; + name = "GlobalDef_LocationGroupProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 148; + name = "GlobalDef_LocationProperty"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 149; + name = "GlobalDef_MetricClass"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __metricMembers_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricMembers[__metricMembers_len]; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricOccurrence; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } recorderKind; + } align(1); +}; + +event { + stream_id = 0; + id = 150; + name = "GlobalDef_MetricClassRecorder"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + } align(1); +}; + +event { + stream_id = 0; + id = 151; + name = "GlobalDef_MetricInstance"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricClass; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricScope; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 152; + name = "GlobalDef_MetricMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } valueType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unit; + } align(1); +}; + +event { + stream_id = 0; + id = 153; + name = "GlobalDef_Paradigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigmClass; + } align(1); +}; + +event { + stream_id = 0; + id = 154; + name = "GlobalDef_ParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } property; + } align(1); +}; + +event { + stream_id = 0; + id = 155; + name = "GlobalDef_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } parameterType; + } align(1); +}; + +event { + stream_id = 0; + id = 156; + name = "GlobalDef_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } canonicalName; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } regionRole; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } regionFlag; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } beginLineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } endLineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 157; + name = "GlobalDef_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + } align(1); +}; + +event { + stream_id = 0; + id = 158; + name = "GlobalDef_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 159; + name = "GlobalDef_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + string { + encoding = UTF8; + } stringValue; + } align(1); +}; + +event { + stream_id = 0; + id = 160; + name = "GlobalDef_SystemTreeNode"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } className; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 161; + name = "GlobalDef_SystemTreeNodeDomain"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } systemTreeDomain; + } align(1); +}; + +event { + stream_id = 0; + id = 162; + name = "GlobalDef_SystemTreeNodeProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 163; + name = "MetricValue_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 164; + name = "MetricValue_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 165; + name = "MetricValue_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/profile.cubex b/test_selection/dorsal-lab_testcases/mpi_bsend/profile.cubex new file mode 100755 index 0000000..92d1f50 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/profile.cubex differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/scorep.cfg b/test_selection/dorsal-lab_testcases/mpi_bsend/scorep.cfg new file mode 100755 index 0000000..0a86cd8 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_bsend/scorep.cfg @@ -0,0 +1,45 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces.def b/test_selection/dorsal-lab_testcases/mpi_bsend/traces.def new file mode 100755 index 0000000..d841cd2 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces.otf2 b/test_selection/dorsal-lab_testcases/mpi_bsend/traces.otf2 new file mode 100755 index 0000000..397af51 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces.otf2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.def b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.def new file mode 100755 index 0000000..da9d82d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.evt b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.evt new file mode 100755 index 0000000..d0f10c6 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.def b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.def new file mode 100755 index 0000000..32ee400 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.evt b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.evt new file mode 100755 index 0000000..995e9e0 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_bsend/traces/1.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/MANIFEST.md b/test_selection/dorsal-lab_testcases/mpi_gather/MANIFEST.md new file mode 100755 index 0000000..0918bda --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_gather/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/0 b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/0 new file mode 100755 index 0000000..14dd7e4 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/0 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/1 b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/1 new file mode 100755 index 0000000..0cf58ca Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/1 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/2 b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/2 new file mode 100755 index 0000000..de82845 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/3 b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/3 new file mode 100755 index 0000000..6a2228d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/3 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/global_def b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/global_def new file mode 100755 index 0000000..00daf03 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/global_def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/metadata b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/metadata new file mode 100755 index 0000000..87800de --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_gather/converted_otf2_26704_1641396604/metadata @@ -0,0 +1,4752 @@ +/* CTF 1.8 */ + +/* + * The MIT License (MIT) + * + * Copyright (c) 2015-2020 Philippe Proulx + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * + * The following code was generated by barectf v3.0.1 + * on 2021-12-23T15:22:42.642623. + * + * For more details, see . + */ + +trace { + major = 1; + minor = 8; + byte_order = le; + packet.header := struct { + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } magic; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } stream_id; + } align(8); +}; + +env { + domain = "bare"; + tracer_name = "otf2"; + tracer_major = 3; + tracer_minor = 0; + tracer_patch = 1; + tracer_pre = ""; + barectf_gen_date = "2021-12-23T15:22:42.642623"; +}; + +clock { + name = default; + freq = 3293832152; + precision = 0; + offset_s = 1641387136; + offset = 958208807; + absolute = false; +}; + +/* Data stream type `default` */ +stream { + id = 0; + packet.context := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } packet_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } content_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_begin; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_end; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } events_discarded; + } align(8); + event.header := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } id; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp; + } align(8); +}; + +event { + stream_id = 0; + id = 0; + name = "EventAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 1; + name = "EventAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 2; + name = "EventAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 3; + name = "EventAttribute_Double"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 4; + name = "EventAttribute_Float"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 5; + name = "EventAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 6; + name = "EventAttribute_Int16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 7; + name = "EventAttribute_Int32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 8; + name = "EventAttribute_Int64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 9; + name = "EventAttribute_Int8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 10; + name = "EventAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 11; + name = "EventAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 12; + name = "EventAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 13; + name = "EventAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 14; + name = "EventAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 15; + name = "EventAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 16; + name = "EventAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 17; + name = "EventAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 18; + name = "EventAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 19; + name = "EventAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 20; + name = "EventAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 21; + name = "EventAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 22; + name = "EventAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 23; + name = "EventAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 24; + name = "Event_BufferFlush"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } stopTime; + } align(1); +}; + +event { + stream_id = 0; + id = 25; + name = "Event_CallingContextEnter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + } align(1); +}; + +event { + stream_id = 0; + id = 26; + name = "Event_CallingContextLeave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + } align(1); +}; + +event { + stream_id = 0; + id = 27; + name = "Event_CallingContextSample"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } interruptGenerator; + } align(1); +}; + +event { + stream_id = 0; + id = 28; + name = "Event_Enter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 29; + name = "Event_IoAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 30; + name = "Event_IoChangeStatusFlags"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 31; + name = "Event_IoCreateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creationFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 32; + name = "Event_IoDeleteFile"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + } align(1); +}; + +event { + stream_id = 0; + id = 33; + name = "Event_IoDestroyHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + } align(1); +}; + +event { + stream_id = 0; + id = 34; + name = "Event_IoDuplicateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } oldHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } newHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 35; + name = "Event_IoOperationBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } operationFlags; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesRequest; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 36; + name = "Event_IoOperationCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 37; + name = "Event_IoOperationComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesResult; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 38; + name = "Event_IoOperationIssued"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 39; + name = "Event_IoOperationTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 40; + name = "Event_IoReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 41; + name = "Event_IoSeek"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetRequest; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } whence; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetResult; + } align(1); +}; + +event { + stream_id = 0; + id = 42; + name = "Event_IoTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 43; + name = "Event_Leave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 44; + name = "Event_MeasurementOnOff"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } measurementMode; + } align(1); +}; + +event { + stream_id = 0; + id = 45; + name = "Event_Metric"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfMetrics; + } align(1); +}; + +event { + stream_id = 0; + id = 46; + name = "Event_MpiCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 47; + name = "Event_MpiCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 48; + name = "Event_MpiIrecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 49; + name = "Event_MpiIrecvRequest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 50; + name = "Event_MpiIsend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 51; + name = "Event_MpiIsendComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 52; + name = "Event_MpiRecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 53; + name = "Event_MpiRequestCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 54; + name = "Event_MpiRequestTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 55; + name = "Event_MpiSend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 56; + name = "Event_OmpAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 57; + name = "Event_OmpFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfRequestedThreads; + } align(1); +}; + +event { + stream_id = 0; + id = 58; + name = "Event_OmpJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 59; + name = "Event_OmpReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 60; + name = "Event_OmpTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 61; + name = "Event_OmpTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 62; + name = "Event_OmpTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 63; + name = "Event_ParameterInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 64; + name = "Event_ParameterString"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } stringID; + } align(1); +}; + +event { + stream_id = 0; + id = 65; + name = "Event_ParameterUnsignedInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 66; + name = "Event_ProgramArgument"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programArgument; + } align(1); +}; + +event { + stream_id = 0; + id = 67; + name = "Event_ProgramBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programName; + } align(1); +}; + +event { + stream_id = 0; + id = 68; + name = "Event_ProgramEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exitStatus; + } align(1); +}; + +event { + stream_id = 0; + id = 69; + name = "Event_RmaAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 70; + name = "Event_RmaAtomic"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 71; + name = "Event_RmaCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 72; + name = "Event_RmaCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 73; + name = "Event_RmaGet"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 74; + name = "Event_RmaGroupSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + } align(1); +}; + +event { + stream_id = 0; + id = 75; + name = "Event_RmaOpCompleteBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 76; + name = "Event_RmaOpCompleteNonBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 77; + name = "Event_RmaOpCompleteRemote"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 78; + name = "Event_RmaOpTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 79; + name = "Event_RmaPut"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 80; + name = "Event_RmaReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + } align(1); +}; + +event { + stream_id = 0; + id = 81; + name = "Event_RmaRequestLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 82; + name = "Event_RmaSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } syncType; + } align(1); +}; + +event { + stream_id = 0; + id = 83; + name = "Event_RmaTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 84; + name = "Event_RmaWaitChange"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 85; + name = "Event_RmaWinCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 86; + name = "Event_RmaWinDestroy"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 87; + name = "Event_ThreadAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 88; + name = "Event_ThreadBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 89; + name = "Event_ThreadCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 90; + name = "Event_ThreadEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 91; + name = "Event_ThreadFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } matchnumberOfRequestedThreadsingId; + } align(1); +}; + +event { + stream_id = 0; + id = 92; + name = "Event_ThreadJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + } align(1); +}; + +event { + stream_id = 0; + id = 93; + name = "Event_ThreadReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 94; + name = "Event_ThreadTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 95; + name = "Event_ThreadTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 96; + name = "Event_ThreadTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 97; + name = "Event_ThreadTeamBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 98; + name = "Event_ThreadTeamEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 99; + name = "Event_ThreadWait"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 100; + name = "GlobalDefAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 101; + name = "GlobalDefAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 102; + name = "GlobalDefAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 103; + name = "GlobalDefAttribute_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 104; + name = "GlobalDefAttribute_Float"; + fields := struct { + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 105; + name = "GlobalDefAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 106; + name = "GlobalDefAttribute_Int16"; + fields := struct { + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 107; + name = "GlobalDefAttribute_Int32"; + fields := struct { + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 108; + name = "GlobalDefAttribute_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 109; + name = "GlobalDefAttribute_Int8"; + fields := struct { + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 110; + name = "GlobalDefAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 111; + name = "GlobalDefAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 112; + name = "GlobalDefAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 113; + name = "GlobalDefAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 114; + name = "GlobalDefAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 115; + name = "GlobalDefAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 116; + name = "GlobalDefAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 117; + name = "GlobalDefAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 118; + name = "GlobalDefAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 119; + name = "GlobalDefAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 120; + name = "GlobalDefAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 121; + name = "GlobalDefAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 122; + name = "GlobalDefAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 123; + name = "GlobalDefAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 124; + name = "GlobalDef_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + } align(1); +}; + +event { + stream_id = 0; + id = 125; + name = "GlobalDef_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceCodeLocation; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 126; + name = "GlobalDef_CallingContextProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 127; + name = "GlobalDef_Callpath"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 128; + name = "GlobalDef_CallpathParameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callpath; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + } align(1); +}; + +event { + stream_id = 0; + id = 129; + name = "GlobalDef_Callsite"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } enteredRegion; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } leftRegion; + } align(1); +}; + +event { + stream_id = 0; + id = 130; + name = "GlobalDef_CartCoordinate"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartTopology; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __coordinates_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } coordinates[__coordinates_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 131; + name = "GlobalDef_CartDimension"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } size; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } cartPeriodicity; + } align(1); +}; + +event { + stream_id = 0; + id = 132; + name = "GlobalDef_CartTopology"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __cartDimensions_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartDimensions[__cartDimensions_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 133; + name = "GlobalDef_ClockProperties"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } timerResolution; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } globalOffset; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } traceLength; + } align(1); +}; + +event { + stream_id = 0; + id = 134; + name = "GlobalDef_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 135; + name = "GlobalDef_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } groupType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } groupFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfMembers; + } align(1); +}; + +event { + stream_id = 0; + id = 136; + name = "GlobalDef_GroupMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + } align(1); +}; + +event { + stream_id = 0; + id = 137; + name = "GlobalDef_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } interruptGeneratorMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } period; + } align(1); +}; + +event { + stream_id = 0; + id = 138; + name = "GlobalDef_IoDirectory"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 139; + name = "GlobalDef_IoFileProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 140; + name = "GlobalDef_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandleFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 141; + name = "GlobalDef_IoParadigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } identification; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmClass; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioParadigmFlags; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfProperties; + } align(1); +}; + +event { + stream_id = 0; + id = 142; + name = "GlobalDef_IoParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmProperty; + } align(1); +}; + +event { + stream_id = 0; + id = 143; + name = "GlobalDef_IoPreCreatedHandleState"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 144; + name = "GlobalDef_IoRegularFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 145; + name = "GlobalDef_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationType; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } numberOfEvents; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + } align(1); +}; + +event { + stream_id = 0; + id = 146; + name = "GlobalDef_LocationGroup"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationGroupType; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 147; + name = "GlobalDef_LocationGroupProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 148; + name = "GlobalDef_LocationProperty"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 149; + name = "GlobalDef_MetricClass"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __metricMembers_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricMembers[__metricMembers_len]; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricOccurrence; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } recorderKind; + } align(1); +}; + +event { + stream_id = 0; + id = 150; + name = "GlobalDef_MetricClassRecorder"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + } align(1); +}; + +event { + stream_id = 0; + id = 151; + name = "GlobalDef_MetricInstance"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricClass; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricScope; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 152; + name = "GlobalDef_MetricMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } valueType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unit; + } align(1); +}; + +event { + stream_id = 0; + id = 153; + name = "GlobalDef_Paradigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigmClass; + } align(1); +}; + +event { + stream_id = 0; + id = 154; + name = "GlobalDef_ParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } property; + } align(1); +}; + +event { + stream_id = 0; + id = 155; + name = "GlobalDef_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } parameterType; + } align(1); +}; + +event { + stream_id = 0; + id = 156; + name = "GlobalDef_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } canonicalName; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } regionRole; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } regionFlag; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } beginLineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } endLineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 157; + name = "GlobalDef_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + } align(1); +}; + +event { + stream_id = 0; + id = 158; + name = "GlobalDef_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 159; + name = "GlobalDef_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + string { + encoding = UTF8; + } stringValue; + } align(1); +}; + +event { + stream_id = 0; + id = 160; + name = "GlobalDef_SystemTreeNode"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } className; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 161; + name = "GlobalDef_SystemTreeNodeDomain"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } systemTreeDomain; + } align(1); +}; + +event { + stream_id = 0; + id = 162; + name = "GlobalDef_SystemTreeNodeProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 163; + name = "MetricValue_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 164; + name = "MetricValue_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 165; + name = "MetricValue_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/profile.cubex b/test_selection/dorsal-lab_testcases/mpi_gather/profile.cubex new file mode 100755 index 0000000..6ac16a5 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/profile.cubex differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/scorep.cfg b/test_selection/dorsal-lab_testcases/mpi_gather/scorep.cfg new file mode 100755 index 0000000..a5d33a5 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_gather/scorep.cfg @@ -0,0 +1,44 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces.def b/test_selection/dorsal-lab_testcases/mpi_gather/traces.def new file mode 100755 index 0000000..11ff905 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces.otf2 b/test_selection/dorsal-lab_testcases/mpi_gather/traces.otf2 new file mode 100755 index 0000000..6aa5614 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces.otf2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.def b/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.def new file mode 100755 index 0000000..b74bda7 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.evt b/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.evt new file mode 100755 index 0000000..72b8dcb Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.def b/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.def new file mode 100755 index 0000000..c34551e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.evt b/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.evt new file mode 100755 index 0000000..10fb2a3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/1.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.def b/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.def new file mode 100755 index 0000000..8c9af5c Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.evt b/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.evt new file mode 100755 index 0000000..de886bd Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/2.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.def b/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.def new file mode 100755 index 0000000..2cc2e25 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.evt b/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.evt new file mode 100755 index 0000000..26bb4f7 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_gather/traces/3.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/MANIFEST.md b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/MANIFEST.md new file mode 100755 index 0000000..4ae7083 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/MANIFEST.md @@ -0,0 +1,29 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING + SCOREP_TIMER diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/0 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/0 new file mode 100755 index 0000000..a61d551 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/0 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/1 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/1 new file mode 100755 index 0000000..9de0460 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/1 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/2 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/2 new file mode 100755 index 0000000..85cd037 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/3 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/3 new file mode 100755 index 0000000..0a46c87 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/3 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967296 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967296 new file mode 100755 index 0000000..b03ad25 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967296 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967297 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967297 new file mode 100755 index 0000000..6ff7b18 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967297 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967298 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967298 new file mode 100755 index 0000000..0863411 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967298 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967299 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967299 new file mode 100755 index 0000000..da507ea Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/4294967299 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934592 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934592 new file mode 100755 index 0000000..460eaab Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934592 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934593 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934593 new file mode 100755 index 0000000..c5d7e91 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934593 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934594 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934594 new file mode 100755 index 0000000..a0b0460 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934594 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934595 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934595 new file mode 100755 index 0000000..99cd076 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/8589934595 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/global_def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/global_def new file mode 100755 index 0000000..e9e2bf5 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/global_def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/metadata b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/metadata new file mode 100755 index 0000000..5624fe9 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/converted_otf2_1155414_1645185502/metadata @@ -0,0 +1,4752 @@ +/* CTF 1.8 */ + +/* + * The MIT License (MIT) + * + * Copyright (c) 2015-2020 Philippe Proulx + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * + * The following code was generated by barectf v3.0.1 + * on 2021-10-29T15:39:33.565575. + * + * For more details, see . + */ + +trace { + major = 1; + minor = 8; + byte_order = le; + packet.header := struct { + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } magic; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } stream_id; + } align(8); +}; + +env { + domain = "bare"; + tracer_name = "otf2"; + tracer_major = 3; + tracer_minor = 0; + tracer_patch = 1; + tracer_pre = ""; + barectf_gen_date = "2021-10-29T15:39:33.565575"; +}; + +clock { + name = default; + freq = 1000000000; + precision = 0; + offset_s = 1644588225; + offset = 114526266; + absolute = false; +}; + +/* Data stream type `default` */ +stream { + id = 0; + packet.context := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } packet_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } content_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_begin; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_end; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } events_discarded; + } align(8); + event.header := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } id; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp; + } align(8); +}; + +event { + stream_id = 0; + id = 0; + name = "EventAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 1; + name = "EventAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 2; + name = "EventAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 3; + name = "EventAttribute_Double"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 4; + name = "EventAttribute_Float"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 5; + name = "EventAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 6; + name = "EventAttribute_Int16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 7; + name = "EventAttribute_Int32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 8; + name = "EventAttribute_Int64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 9; + name = "EventAttribute_Int8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 10; + name = "EventAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 11; + name = "EventAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 12; + name = "EventAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 13; + name = "EventAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 14; + name = "EventAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 15; + name = "EventAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 16; + name = "EventAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 17; + name = "EventAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 18; + name = "EventAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 19; + name = "EventAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 20; + name = "EventAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 21; + name = "EventAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 22; + name = "EventAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 23; + name = "EventAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 24; + name = "Event_BufferFlush"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } stopTime; + } align(1); +}; + +event { + stream_id = 0; + id = 25; + name = "Event_CallingContextEnter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + } align(1); +}; + +event { + stream_id = 0; + id = 26; + name = "Event_CallingContextLeave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + } align(1); +}; + +event { + stream_id = 0; + id = 27; + name = "Event_CallingContextSample"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } interruptGenerator; + } align(1); +}; + +event { + stream_id = 0; + id = 28; + name = "Event_Enter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 29; + name = "Event_IoAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 30; + name = "Event_IoChangeStatusFlags"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 31; + name = "Event_IoCreateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creationFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 32; + name = "Event_IoDeleteFile"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + } align(1); +}; + +event { + stream_id = 0; + id = 33; + name = "Event_IoDestroyHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + } align(1); +}; + +event { + stream_id = 0; + id = 34; + name = "Event_IoDuplicateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } oldHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } newHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 35; + name = "Event_IoOperationBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } operationFlags; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesRequest; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 36; + name = "Event_IoOperationCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 37; + name = "Event_IoOperationComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesResult; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 38; + name = "Event_IoOperationIssued"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 39; + name = "Event_IoOperationTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 40; + name = "Event_IoReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 41; + name = "Event_IoSeek"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetRequest; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } whence; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetResult; + } align(1); +}; + +event { + stream_id = 0; + id = 42; + name = "Event_IoTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 43; + name = "Event_Leave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 44; + name = "Event_MeasurementOnOff"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } measurementMode; + } align(1); +}; + +event { + stream_id = 0; + id = 45; + name = "Event_Metric"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfMetrics; + } align(1); +}; + +event { + stream_id = 0; + id = 46; + name = "Event_MpiCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 47; + name = "Event_MpiCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 48; + name = "Event_MpiIrecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 49; + name = "Event_MpiIrecvRequest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 50; + name = "Event_MpiIsend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 51; + name = "Event_MpiIsendComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 52; + name = "Event_MpiRecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 53; + name = "Event_MpiRequestCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 54; + name = "Event_MpiRequestTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 55; + name = "Event_MpiSend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 56; + name = "Event_OmpAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 57; + name = "Event_OmpFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfRequestedThreads; + } align(1); +}; + +event { + stream_id = 0; + id = 58; + name = "Event_OmpJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 59; + name = "Event_OmpReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 60; + name = "Event_OmpTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 61; + name = "Event_OmpTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 62; + name = "Event_OmpTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 63; + name = "Event_ParameterInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 64; + name = "Event_ParameterString"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } stringID; + } align(1); +}; + +event { + stream_id = 0; + id = 65; + name = "Event_ParameterUnsignedInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 66; + name = "Event_ProgramArgument"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programArgument; + } align(1); +}; + +event { + stream_id = 0; + id = 67; + name = "Event_ProgramBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programName; + } align(1); +}; + +event { + stream_id = 0; + id = 68; + name = "Event_ProgramEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exitStatus; + } align(1); +}; + +event { + stream_id = 0; + id = 69; + name = "Event_RmaAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 70; + name = "Event_RmaAtomic"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 71; + name = "Event_RmaCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 72; + name = "Event_RmaCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 73; + name = "Event_RmaGet"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 74; + name = "Event_RmaGroupSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + } align(1); +}; + +event { + stream_id = 0; + id = 75; + name = "Event_RmaOpCompleteBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 76; + name = "Event_RmaOpCompleteNonBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 77; + name = "Event_RmaOpCompleteRemote"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 78; + name = "Event_RmaOpTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 79; + name = "Event_RmaPut"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 80; + name = "Event_RmaReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + } align(1); +}; + +event { + stream_id = 0; + id = 81; + name = "Event_RmaRequestLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 82; + name = "Event_RmaSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } syncType; + } align(1); +}; + +event { + stream_id = 0; + id = 83; + name = "Event_RmaTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 84; + name = "Event_RmaWaitChange"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 85; + name = "Event_RmaWinCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 86; + name = "Event_RmaWinDestroy"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 87; + name = "Event_ThreadAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 88; + name = "Event_ThreadBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 89; + name = "Event_ThreadCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 90; + name = "Event_ThreadEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 91; + name = "Event_ThreadFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } matchnumberOfRequestedThreadsingId; + } align(1); +}; + +event { + stream_id = 0; + id = 92; + name = "Event_ThreadJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + } align(1); +}; + +event { + stream_id = 0; + id = 93; + name = "Event_ThreadReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 94; + name = "Event_ThreadTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 95; + name = "Event_ThreadTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 96; + name = "Event_ThreadTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 97; + name = "Event_ThreadTeamBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 98; + name = "Event_ThreadTeamEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 99; + name = "Event_ThreadWait"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 100; + name = "GlobalDefAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 101; + name = "GlobalDefAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 102; + name = "GlobalDefAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 103; + name = "GlobalDefAttribute_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 104; + name = "GlobalDefAttribute_Float"; + fields := struct { + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 105; + name = "GlobalDefAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 106; + name = "GlobalDefAttribute_Int16"; + fields := struct { + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 107; + name = "GlobalDefAttribute_Int32"; + fields := struct { + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 108; + name = "GlobalDefAttribute_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 109; + name = "GlobalDefAttribute_Int8"; + fields := struct { + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 110; + name = "GlobalDefAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 111; + name = "GlobalDefAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 112; + name = "GlobalDefAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 113; + name = "GlobalDefAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 114; + name = "GlobalDefAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 115; + name = "GlobalDefAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 116; + name = "GlobalDefAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 117; + name = "GlobalDefAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 118; + name = "GlobalDefAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 119; + name = "GlobalDefAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 120; + name = "GlobalDefAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 121; + name = "GlobalDefAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 122; + name = "GlobalDefAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 123; + name = "GlobalDefAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 124; + name = "GlobalDef_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + } align(1); +}; + +event { + stream_id = 0; + id = 125; + name = "GlobalDef_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceCodeLocation; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 126; + name = "GlobalDef_CallingContextProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 127; + name = "GlobalDef_Callpath"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 128; + name = "GlobalDef_CallpathParameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callpath; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + } align(1); +}; + +event { + stream_id = 0; + id = 129; + name = "GlobalDef_Callsite"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } enteredRegion; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } leftRegion; + } align(1); +}; + +event { + stream_id = 0; + id = 130; + name = "GlobalDef_CartCoordinate"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartTopology; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __coordinates_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } coordinates[__coordinates_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 131; + name = "GlobalDef_CartDimension"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } size; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } cartPeriodicity; + } align(1); +}; + +event { + stream_id = 0; + id = 132; + name = "GlobalDef_CartTopology"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __cartDimensions_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartDimensions[__cartDimensions_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 133; + name = "GlobalDef_ClockProperties"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } timerResolution; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } globalOffset; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } traceLength; + } align(1); +}; + +event { + stream_id = 0; + id = 134; + name = "GlobalDef_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 135; + name = "GlobalDef_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } groupType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } groupFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfMembers; + } align(1); +}; + +event { + stream_id = 0; + id = 136; + name = "GlobalDef_GroupMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + } align(1); +}; + +event { + stream_id = 0; + id = 137; + name = "GlobalDef_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } interruptGeneratorMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } period; + } align(1); +}; + +event { + stream_id = 0; + id = 138; + name = "GlobalDef_IoDirectory"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 139; + name = "GlobalDef_IoFileProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 140; + name = "GlobalDef_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandleFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 141; + name = "GlobalDef_IoParadigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } identification; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmClass; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioParadigmFlags; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfProperties; + } align(1); +}; + +event { + stream_id = 0; + id = 142; + name = "GlobalDef_IoParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmProperty; + } align(1); +}; + +event { + stream_id = 0; + id = 143; + name = "GlobalDef_IoPreCreatedHandleState"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 144; + name = "GlobalDef_IoRegularFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 145; + name = "GlobalDef_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationType; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } numberOfEvents; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + } align(1); +}; + +event { + stream_id = 0; + id = 146; + name = "GlobalDef_LocationGroup"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationGroupType; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 147; + name = "GlobalDef_LocationGroupProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 148; + name = "GlobalDef_LocationProperty"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 149; + name = "GlobalDef_MetricClass"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __metricMembers_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricMembers[__metricMembers_len]; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricOccurrence; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } recorderKind; + } align(1); +}; + +event { + stream_id = 0; + id = 150; + name = "GlobalDef_MetricClassRecorder"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + } align(1); +}; + +event { + stream_id = 0; + id = 151; + name = "GlobalDef_MetricInstance"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricClass; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricScope; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 152; + name = "GlobalDef_MetricMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } valueType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unit; + } align(1); +}; + +event { + stream_id = 0; + id = 153; + name = "GlobalDef_Paradigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigmClass; + } align(1); +}; + +event { + stream_id = 0; + id = 154; + name = "GlobalDef_ParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } property; + } align(1); +}; + +event { + stream_id = 0; + id = 155; + name = "GlobalDef_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } parameterType; + } align(1); +}; + +event { + stream_id = 0; + id = 156; + name = "GlobalDef_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } canonicalName; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } regionRole; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } regionFlag; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } beginLineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } endLineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 157; + name = "GlobalDef_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + } align(1); +}; + +event { + stream_id = 0; + id = 158; + name = "GlobalDef_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 159; + name = "GlobalDef_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + string { + encoding = UTF8; + } stringValue; + } align(1); +}; + +event { + stream_id = 0; + id = 160; + name = "GlobalDef_SystemTreeNode"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } className; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 161; + name = "GlobalDef_SystemTreeNodeDomain"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } systemTreeDomain; + } align(1); +}; + +event { + stream_id = 0; + id = 162; + name = "GlobalDef_SystemTreeNodeProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 163; + name = "MetricValue_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 164; + name = "MetricValue_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 165; + name = "MetricValue_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/profile.cubex b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/profile.cubex new file mode 100755 index 0000000..74239e5 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/profile.cubex differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/scorep.cfg b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/scorep.cfg new file mode 100755 index 0000000..1daab8a --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/scorep.cfg @@ -0,0 +1,51 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_ENABLE_UNWINDING=false +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='clock_gettime' +SCOREP_NM_SYMBOLS='' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_TRACING_CONVERT_CALLING_CONTEXT_EVENTS=false +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_SAMPLING_EVENTS='perf_cycles@10000000' +SCOREP_SAMPLING_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_USER=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_SELECTIVE_CONFIG_FILE='' +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.def new file mode 100755 index 0000000..95ca4ea Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.otf2 b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.otf2 new file mode 100755 index 0000000..200ebef Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces.otf2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.def new file mode 100755 index 0000000..61f9ff3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.evt new file mode 100755 index 0000000..2cbacf4 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.def new file mode 100755 index 0000000..27efec8 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.evt new file mode 100755 index 0000000..30f241e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/1.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.def new file mode 100755 index 0000000..40d16ef Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.evt new file mode 100755 index 0000000..e2ac753 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/2.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.def new file mode 100755 index 0000000..259ff4e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.evt new file mode 100755 index 0000000..f5e4759 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/3.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.def new file mode 100755 index 0000000..61f9ff3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.evt new file mode 100755 index 0000000..963dbdb Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967296.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.def new file mode 100755 index 0000000..27efec8 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.evt new file mode 100755 index 0000000..18a201e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967297.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.def new file mode 100755 index 0000000..40d16ef Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.evt new file mode 100755 index 0000000..389b861 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967298.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.def new file mode 100755 index 0000000..259ff4e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.evt new file mode 100755 index 0000000..8409daa Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/4294967299.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.def new file mode 100755 index 0000000..61f9ff3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.evt new file mode 100755 index 0000000..7192360 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934592.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.def new file mode 100755 index 0000000..27efec8 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.evt new file mode 100755 index 0000000..8c0fc3f Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934593.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.def new file mode 100755 index 0000000..40d16ef Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.evt new file mode 100755 index 0000000..6514210 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934594.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.def b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.def new file mode 100755 index 0000000..259ff4e Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.evt b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.evt new file mode 100755 index 0000000..efa569c Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_pthread_hello_world/traces/8589934595.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/MANIFEST.md b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/MANIFEST.md new file mode 100755 index 0000000..0918bda --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/0 b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/0 new file mode 100755 index 0000000..f26b8a7 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/0 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/1 b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/1 new file mode 100755 index 0000000..a120f66 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/1 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/global_def b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/global_def new file mode 100755 index 0000000..ede6fcb Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/global_def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/metadata b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/metadata new file mode 100755 index 0000000..5689697 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/converted_otf2_15802_1641473640/metadata @@ -0,0 +1,4752 @@ +/* CTF 1.8 */ + +/* + * The MIT License (MIT) + * + * Copyright (c) 2015-2020 Philippe Proulx + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * + * The following code was generated by barectf v3.0.1 + * on 2021-12-23T15:22:42.642623. + * + * For more details, see . + */ + +trace { + major = 1; + minor = 8; + byte_order = le; + packet.header := struct { + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } magic; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } stream_id; + } align(8); +}; + +env { + domain = "bare"; + tracer_name = "otf2"; + tracer_major = 3; + tracer_minor = 0; + tracer_patch = 1; + tracer_pre = ""; + barectf_gen_date = "2021-12-23T15:22:42.642623"; +}; + +clock { + name = default; + freq = 3293918985; + precision = 0; + offset_s = 1641468933; + offset = 670816444; + absolute = false; +}; + +/* Data stream type `default` */ +stream { + id = 0; + packet.context := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } packet_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } content_size; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_begin; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp_end; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } events_discarded; + } align(8); + event.header := struct { + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + } id; + integer { + signed = false; + size = 64; + align = 8; + byte_order = native; + base = 10; + map = clock.default.value; + } timestamp; + } align(8); +}; + +event { + stream_id = 0; + id = 0; + name = "EventAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 1; + name = "EventAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 2; + name = "EventAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 3; + name = "EventAttribute_Double"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 4; + name = "EventAttribute_Float"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 5; + name = "EventAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 6; + name = "EventAttribute_Int16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 7; + name = "EventAttribute_Int32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 8; + name = "EventAttribute_Int64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 9; + name = "EventAttribute_Int8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 10; + name = "EventAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 11; + name = "EventAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 12; + name = "EventAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 13; + name = "EventAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 14; + name = "EventAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 15; + name = "EventAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 16; + name = "EventAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 17; + name = "EventAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 18; + name = "EventAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 19; + name = "EventAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 20; + name = "EventAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 21; + name = "EventAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 22; + name = "EventAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 23; + name = "EventAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } attribute; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 24; + name = "Event_BufferFlush"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } stopTime; + } align(1); +}; + +event { + stream_id = 0; + id = 25; + name = "Event_CallingContextEnter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + } align(1); +}; + +event { + stream_id = 0; + id = 26; + name = "Event_CallingContextLeave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + } align(1); +}; + +event { + stream_id = 0; + id = 27; + name = "Event_CallingContextSample"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unwindDistance; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } interruptGenerator; + } align(1); +}; + +event { + stream_id = 0; + id = 28; + name = "Event_Enter"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 29; + name = "Event_IoAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 30; + name = "Event_IoChangeStatusFlags"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 31; + name = "Event_IoCreateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creationFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 32; + name = "Event_IoDeleteFile"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + } align(1); +}; + +event { + stream_id = 0; + id = 33; + name = "Event_IoDestroyHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + } align(1); +}; + +event { + stream_id = 0; + id = 34; + name = "Event_IoDuplicateHandle"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } oldHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } newHandle; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 35; + name = "Event_IoOperationBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } operationFlags; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesRequest; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 36; + name = "Event_IoOperationCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 37; + name = "Event_IoOperationComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesResult; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 38; + name = "Event_IoOperationIssued"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 39; + name = "Event_IoOperationTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 40; + name = "Event_IoReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 41; + name = "Event_IoSeek"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetRequest; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } whence; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } offsetResult; + } align(1); +}; + +event { + stream_id = 0; + id = 42; + name = "Event_IoTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } handle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 43; + name = "Event_Leave"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 44; + name = "Event_MeasurementOnOff"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } measurementMode; + } align(1); +}; + +event { + stream_id = 0; + id = 45; + name = "Event_Metric"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfMetrics; + } align(1); +}; + +event { + stream_id = 0; + id = 46; + name = "Event_MpiCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 47; + name = "Event_MpiCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sizeReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 48; + name = "Event_MpiIrecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 49; + name = "Event_MpiIrecvRequest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 50; + name = "Event_MpiIsend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 51; + name = "Event_MpiIsendComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 52; + name = "Event_MpiRecv"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sender; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 53; + name = "Event_MpiRequestCancelled"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 54; + name = "Event_MpiRequestTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } requestID; + } align(1); +}; + +event { + stream_id = 0; + id = 55; + name = "Event_MpiSend"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } receiver; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } msgTag; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } msgLength; + } align(1); +}; + +event { + stream_id = 0; + id = 56; + name = "Event_OmpAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 57; + name = "Event_OmpFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfRequestedThreads; + } align(1); +}; + +event { + stream_id = 0; + id = 58; + name = "Event_OmpJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 59; + name = "Event_OmpReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 60; + name = "Event_OmpTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 61; + name = "Event_OmpTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 62; + name = "Event_OmpTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } taskID; + } align(1); +}; + +event { + stream_id = 0; + id = 63; + name = "Event_ParameterInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 64; + name = "Event_ParameterString"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } stringID; + } align(1); +}; + +event { + stream_id = 0; + id = 65; + name = "Event_ParameterUnsignedInt"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 66; + name = "Event_ProgramArgument"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programArgument; + } align(1); +}; + +event { + stream_id = 0; + id = 67; + name = "Event_ProgramBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } programName; + } align(1); +}; + +event { + stream_id = 0; + id = 68; + name = "Event_ProgramEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exitStatus; + } align(1); +}; + +event { + stream_id = 0; + id = 69; + name = "Event_RmaAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 70; + name = "Event_RmaAtomic"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 71; + name = "Event_RmaCollectiveBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + } align(1); +}; + +event { + stream_id = 0; + id = 72; + name = "Event_RmaCollectiveEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } collectiveOp; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } root; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesSent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytesReceived; + } align(1); +}; + +event { + stream_id = 0; + id = 73; + name = "Event_RmaGet"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 74; + name = "Event_RmaGroupSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } syncLevel; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + } align(1); +}; + +event { + stream_id = 0; + id = 75; + name = "Event_RmaOpCompleteBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 76; + name = "Event_RmaOpCompleteNonBlocking"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 77; + name = "Event_RmaOpCompleteRemote"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 78; + name = "Event_RmaOpTest"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 79; + name = "Event_RmaPut"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } bytes; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } matchingId; + } align(1); +}; + +event { + stream_id = 0; + id = 80; + name = "Event_RmaReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + } align(1); +}; + +event { + stream_id = 0; + id = 81; + name = "Event_RmaRequestLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 82; + name = "Event_RmaSync"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } syncType; + } align(1); +}; + +event { + stream_id = 0; + id = 83; + name = "Event_RmaTryLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } remote; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } lockId; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } lockType; + } align(1); +}; + +event { + stream_id = 0; + id = 84; + name = "Event_RmaWaitChange"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 85; + name = "Event_RmaWinCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 86; + name = "Event_RmaWinDestroy"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } win; + } align(1); +}; + +event { + stream_id = 0; + id = 87; + name = "Event_ThreadAcquireLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 88; + name = "Event_ThreadBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 89; + name = "Event_ThreadCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 90; + name = "Event_ThreadEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 91; + name = "Event_ThreadFork"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } matchnumberOfRequestedThreadsingId; + } align(1); +}; + +event { + stream_id = 0; + id = 92; + name = "Event_ThreadJoin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + } align(1); +}; + +event { + stream_id = 0; + id = 93; + name = "Event_ThreadReleaseLock"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } model; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lockID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } acquisitionOrder; + } align(1); +}; + +event { + stream_id = 0; + id = 94; + name = "Event_ThreadTaskComplete"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 95; + name = "Event_ThreadTaskCreate"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 96; + name = "Event_ThreadTaskSwitch"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } creatingThread; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } generationNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 97; + name = "Event_ThreadTeamBegin"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 98; + name = "Event_ThreadTeamEnd"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadTeam; + } align(1); +}; + +event { + stream_id = 0; + id = 99; + name = "Event_ThreadWait"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } locationID; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } threadContingent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } sequenceCount; + } align(1); +}; + +event { + stream_id = 0; + id = 100; + name = "GlobalDefAttribute_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 101; + name = "GlobalDefAttribute_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 102; + name = "GlobalDefAttribute_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 103; + name = "GlobalDefAttribute_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 104; + name = "GlobalDefAttribute_Float"; + fields := struct { + floating_point { + mant_dig = 24; + exp_dig = 8; + align = 32; + byte_order = native; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 105; + name = "GlobalDefAttribute_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 106; + name = "GlobalDefAttribute_Int16"; + fields := struct { + integer { + signed = true; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 107; + name = "GlobalDefAttribute_Int32"; + fields := struct { + integer { + signed = true; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 108; + name = "GlobalDefAttribute_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 109; + name = "GlobalDefAttribute_Int8"; + fields := struct { + integer { + signed = true; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 110; + name = "GlobalDefAttribute_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 111; + name = "GlobalDefAttribute_IoFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 112; + name = "GlobalDefAttribute_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 113; + name = "GlobalDefAttribute_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 114; + name = "GlobalDefAttribute_Metric"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 115; + name = "GlobalDefAttribute_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 116; + name = "GlobalDefAttribute_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 117; + name = "GlobalDefAttribute_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 118; + name = "GlobalDefAttribute_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 119; + name = "GlobalDefAttribute_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 120; + name = "GlobalDefAttribute_UInt16"; + fields := struct { + integer { + signed = false; + size = 16; + align = 16; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 121; + name = "GlobalDefAttribute_UInt32"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 122; + name = "GlobalDefAttribute_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 123; + name = "GlobalDefAttribute_UInt8"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } value; + } align(1); +}; + +event { + stream_id = 0; + id = 124; + name = "GlobalDef_Attribute"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } type; + } align(1); +}; + +event { + stream_id = 0; + id = 125; + name = "GlobalDef_CallingContext"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceCodeLocation; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 126; + name = "GlobalDef_CallingContextProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callingContext; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 127; + name = "GlobalDef_Callpath"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } region; + } align(1); +}; + +event { + stream_id = 0; + id = 128; + name = "GlobalDef_CallpathParameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } callpath; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parameter; + } align(1); +}; + +event { + stream_id = 0; + id = 129; + name = "GlobalDef_Callsite"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } enteredRegion; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } leftRegion; + } align(1); +}; + +event { + stream_id = 0; + id = 130; + name = "GlobalDef_CartCoordinate"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartTopology; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __coordinates_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } coordinates[__coordinates_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 131; + name = "GlobalDef_CartDimension"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } size; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } cartPeriodicity; + } align(1); +}; + +event { + stream_id = 0; + id = 132; + name = "GlobalDef_CartTopology"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } communicator; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __cartDimensions_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } cartDimensions[__cartDimensions_len]; + } align(1); +}; + +event { + stream_id = 0; + id = 133; + name = "GlobalDef_ClockProperties"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } timerResolution; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } globalOffset; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } traceLength; + } align(1); +}; + +event { + stream_id = 0; + id = 134; + name = "GlobalDef_Comm"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 135; + name = "GlobalDef_Group"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } groupType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } groupFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } numberOfMembers; + } align(1); +}; + +event { + stream_id = 0; + id = 136; + name = "GlobalDef_GroupMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } group; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } rank; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + } align(1); +}; + +event { + stream_id = 0; + id = 137; + name = "GlobalDef_InterruptGenerator"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } interruptGeneratorMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } period; + } align(1); +}; + +event { + stream_id = 0; + id = 138; + name = "GlobalDef_IoDirectory"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 139; + name = "GlobalDef_IoFileProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 140; + name = "GlobalDef_IoHandle"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandleFlags; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } parent; + } align(1); +}; + +event { + stream_id = 0; + id = 141; + name = "GlobalDef_IoParadigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } identification; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmClass; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioParadigmFlags; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } numberOfProperties; + } align(1); +}; + +event { + stream_id = 0; + id = 142; + name = "GlobalDef_IoParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } ioParadigmProperty; + } align(1); +}; + +event { + stream_id = 0; + id = 143; + name = "GlobalDef_IoPreCreatedHandleState"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } ioHandle; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } mode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } statusFlags; + } align(1); +}; + +event { + stream_id = 0; + id = 144; + name = "GlobalDef_IoRegularFile"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 145; + name = "GlobalDef_Location"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationType; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } numberOfEvents; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + } align(1); +}; + +event { + stream_id = 0; + id = 146; + name = "GlobalDef_LocationGroup"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } locationGroupType; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 147; + name = "GlobalDef_LocationGroupProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } locationGroup; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 148; + name = "GlobalDef_LocationProperty"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } location; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 149; + name = "GlobalDef_MetricClass"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 8; + byte_order = native; + base = 10; + } __metricMembers_len; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricMembers[__metricMembers_len]; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricOccurrence; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } recorderKind; + } align(1); +}; + +event { + stream_id = 0; + id = 150; + name = "GlobalDef_MetricClassRecorder"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metric; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + } align(1); +}; + +event { + stream_id = 0; + id = 151; + name = "GlobalDef_MetricInstance"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } metricClass; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } recorder; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricScope; + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } scope; + } align(1); +}; + +event { + stream_id = 0; + id = 152; + name = "GlobalDef_MetricMember"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } metricMode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } valueType; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } base; + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } exponent; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } unit; + } align(1); +}; + +event { + stream_id = 0; + id = 153; + name = "GlobalDef_Paradigm"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigmClass; + } align(1); +}; + +event { + stream_id = 0; + id = 154; + name = "GlobalDef_ParadigmProperty"; + fields := struct { + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } property; + } align(1); +}; + +event { + stream_id = 0; + id = 155; + name = "GlobalDef_Parameter"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } parameterType; + } align(1); +}; + +event { + stream_id = 0; + id = 156; + name = "GlobalDef_Region"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } canonicalName; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } description; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } regionRole; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } paradigm; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } regionFlag; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } sourceFile; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } beginLineNumber; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } endLineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 157; + name = "GlobalDef_RmaWin"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } comm; + } align(1); +}; + +event { + stream_id = 0; + id = 158; + name = "GlobalDef_SourceCodeLocation"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } file; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } lineNumber; + } align(1); +}; + +event { + stream_id = 0; + id = 159; + name = "GlobalDef_String"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + string { + encoding = UTF8; + } stringValue; + } align(1); +}; + +event { + stream_id = 0; + id = 160; + name = "GlobalDef_SystemTreeNode"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } self; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } className; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeParent; + } align(1); +}; + +event { + stream_id = 0; + id = 161; + name = "GlobalDef_SystemTreeNodeDomain"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 8; + align = 8; + byte_order = native; + base = 10; + } systemTreeDomain; + } align(1); +}; + +event { + stream_id = 0; + id = 162; + name = "GlobalDef_SystemTreeNodeProperty"; + fields := struct { + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } systemTreeNode; + integer { + signed = false; + size = 32; + align = 32; + byte_order = native; + base = 10; + } name; + } align(1); +}; + +event { + stream_id = 0; + id = 163; + name = "MetricValue_Double"; + fields := struct { + floating_point { + mant_dig = 53; + exp_dig = 11; + align = 64; + byte_order = native; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 164; + name = "MetricValue_Int64"; + fields := struct { + integer { + signed = true; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; + +event { + stream_id = 0; + id = 165; + name = "MetricValue_UInt64"; + fields := struct { + integer { + signed = false; + size = 64; + align = 64; + byte_order = native; + base = 10; + } metricValue; + } align(1); +}; diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/profile.cubex b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/profile.cubex new file mode 100755 index 0000000..e474d68 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/profile.cubex differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/scorep.cfg b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/scorep.cfg new file mode 100755 index 0000000..a5d33a5 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/scorep.cfg @@ -0,0 +1,44 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.def b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.def new file mode 100755 index 0000000..a225016 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.otf2 b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.otf2 new file mode 100755 index 0000000..5f79383 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces.otf2 differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.def b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.def new file mode 100755 index 0000000..2e4dee3 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.evt b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.evt new file mode 100755 index 0000000..764b979 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/0.evt differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.def b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.def new file mode 100755 index 0000000..720185d Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.def differ diff --git a/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.evt b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.evt new file mode 100755 index 0000000..526e067 Binary files /dev/null and b/test_selection/dorsal-lab_testcases/mpi_ssend_irecv/traces/1.evt differ diff --git a/test_selection/dorsal-lab_testcases/src/mpi_allreduce_2communicators.c b/test_selection/dorsal-lab_testcases/src/mpi_allreduce_2communicators.c new file mode 100755 index 0000000..c1d2fd8 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/src/mpi_allreduce_2communicators.c @@ -0,0 +1,45 @@ +/* +*This code was found here : https://www.codingame.com/playgrounds/47058/have-fun-with-mpi-in-c/mpi-communicators +*It is shared under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. https://creativecommons.org/licenses/by-nc-sa/4.0/ +*/ + +#include "mpi.h" +#include +#define NPROCS 8 + +int main(int argc, char *argv[]) { + int rank, new_rank, sendbuf, recvbuf, numtasks, + ranks1[4]={0,1,2,3}, ranks2[4]={4,5,6,7}; + MPI_Group orig_group, new_group; // required variables + MPI_Comm new_comm; // required variable + + MPI_Init(&argc,&argv); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &numtasks); + + + sendbuf = rank; + + // extract the original group handle + MPI_Comm_group(MPI_COMM_WORLD, &orig_group); + + // divide tasks into two distinct groups based upon rank + if (rank < NPROCS/2) { + MPI_Group_incl(orig_group, NPROCS/2, ranks1, &new_group); + } + else { + MPI_Group_incl(orig_group, NPROCS/2, ranks2, &new_group); + } + + // create new new communicator and then perform collective communications + MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm); + MPI_Barrier( MPI_COMM_WORLD ); + MPI_Allreduce(&sendbuf, &recvbuf, 1, MPI_INT, MPI_SUM, new_comm); + + // get rank in new group + MPI_Group_rank (new_group, &new_rank); + printf("rank= %d newrank= %d recvbuf= %d\n",rank,new_rank,recvbuf); + + MPI_Finalize(); + return 0; +} diff --git a/test_selection/dorsal-lab_testcases/src/mpi_bsend.c b/test_selection/dorsal-lab_testcases/src/mpi_bsend.c new file mode 100755 index 0000000..2d13798 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/src/mpi_bsend.c @@ -0,0 +1,64 @@ +//This code was found here https://www.rookiehpc.com/mpi/docs/mpi_bsend.php + #include + #include + #include + + /** + * @brief Illustrates how to send a message in a blocking asynchronous fashion. + * @details This application is meant to be used with 2 processes; 1 sender and + * 1 receiver. The sender will declare a buffer containing enough space for 1 + * message that will contain 1 integer. It then attaches the buffer to MPI and + * issues the MPI_Bsend. Finally, it detaches the buffer and frees it, while the + * receiver prints the message received. + **/ + + int main(int argc, char* argv[]) + { + MPI_Init(&argc, &argv); + + // Get the number of processes and check only 2 are used. + int size; + MPI_Comm_size(MPI_COMM_WORLD, &size); + if(size != 2) + { + printf("This application is meant to be run with 2 processes.\n"); + MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); + } + + // Get my rank and do the corresponding job + enum role_ranks { SENDER, RECEIVER }; + int my_rank; + MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); + switch(my_rank) + { + case SENDER: + { + // Declare the buffer and attach it + int buffer_attached_size = MPI_BSEND_OVERHEAD + sizeof(int); + char* buffer_attached = (char*)malloc(buffer_attached_size); + MPI_Buffer_attach(buffer_attached, buffer_attached_size); + + // Issue the MPI_Bsend + int buffer_sent = 12345; + printf("[MPI process %d] I send value %d.\n", my_rank, buffer_sent); + MPI_Bsend(&buffer_sent, 1, MPI_INT, RECEIVER, 0, MPI_COMM_WORLD); + + // Detach the buffer. It blocks until all messages stored are sent. + MPI_Buffer_detach(&buffer_attached, &buffer_attached_size); + free(buffer_attached); + break; + } + case RECEIVER: + { + // Receive the message and print it. + int received; + MPI_Recv(&received, 1, MPI_INT, SENDER, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); + printf("[MPI process %d] I received value: %d.\n", my_rank, received); + break; + } + } + + MPI_Finalize(); + + return EXIT_SUCCESS; + } diff --git a/test_selection/dorsal-lab_testcases/src/mpi_gather.c b/test_selection/dorsal-lab_testcases/src/mpi_gather.c new file mode 100755 index 0000000..f1b6b4f --- /dev/null +++ b/test_selection/dorsal-lab_testcases/src/mpi_gather.c @@ -0,0 +1,70 @@ +// This code was found here : https://www.rookiehpc.com/mpi/docs/mpi_gather.php + + #include + #include + #include + + /** + * @brief Illustrates how to use a gather. + * @details This application is meant to be run with 4 MPI processes. Every MPI + * process begins with a value, then MPI process 0 is picked to gather all these + * values and print them. It can be visualised as follows: + * + * +-----------+ +-----------+ +-----------+ +-----------+ + * | Process 0 | | Process 1 | | Process 2 | | Process 3 | + * +-+-------+-+ +-+-------+-+ +-+-------+-+ +-+-------+-+ + * | Value | | Value | | Value | | Value | + * | 0 | | 100 | | 200 | | 300 | + * +-------+ +-------+ +-------+ +-------+ + * \ | | / + * \ | | / + * \ | | / + * \ | | / + * \ | | / + * \ | | / + * +-----+-----+-----+-----+ + * | 0 | 100 | 200 | 300 | + * +-----+-----+-----+-----+ + * | Process 0 | + * +-----------------------+ + **/ + int main(int argc, char* argv[]) + { + MPI_Init(&argc, &argv); + + // Get number of processes and check that 4 processes are used + int size; + MPI_Comm_size(MPI_COMM_WORLD, &size); + if(size != 4) + { + printf("This application is meant to be run with 4 MPI processes.\n"); + MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); + } + + // Determine root's rank + int root_rank = 0; + + // Get my rank + int my_rank; + MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); + + // Define my value + int my_value = my_rank * 100; + printf("Process %d, my value = %d.\n", my_rank, my_value); + + if(my_rank == root_rank) + { + int buffer[4]; + MPI_Gather(&my_value, 1, MPI_INT, buffer, 1, MPI_INT, root_rank, MPI_COMM_WORLD); + printf("Values collected on process %d: %d, %d, %d, %d.\n", my_rank, buffer[0], buffer[1], buffer[2], buffer[3]); + } + else + { + MPI_Gather(&my_value, 1, MPI_INT, NULL, 0, MPI_INT, root_rank, MPI_COMM_WORLD); + } + + MPI_Finalize(); + + return EXIT_SUCCESS; + } + diff --git a/test_selection/dorsal-lab_testcases/src/mpi_pthread_hello_world.c b/test_selection/dorsal-lab_testcases/src/mpi_pthread_hello_world.c new file mode 100755 index 0000000..b634ff0 --- /dev/null +++ b/test_selection/dorsal-lab_testcases/src/mpi_pthread_hello_world.c @@ -0,0 +1,42 @@ +#include +#include "mpi.h" +#include +#include + +int rank, nprocs; + +void *print_hello_world(int id) +{ + SCOREP_USER_REGION_DEFINE( print_hello_world_region ) + SCOREP_USER_REGION_BEGIN( print_hello_world_region, "print_hello_world", SCOREP_USER_REGION_TYPE_COMMON ) + printf(" Hello World! From Thread:%d On Process: %d. \n", id, rank); + SCOREP_USER_REGION_END( print_hello_world_region ) + return NULL; +} + +void main(int argc, char *argv[]) +{ + SCOREP_USER_REGION_DEFINE( main_region ) + SCOREP_USER_REGION_BEGIN( main_region, "main", SCOREP_USER_REGION_TYPE_COMMON ) + pthread_t thread1, thread2; + + MPI_Status status; + + MPI_Init(&argc, &argv); + MPI_Comm_size(MPI_COMM_WORLD, &nprocs); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + + + pthread_create(&thread1, NULL, (void *(*) (void *)) print_hello_world, (void *) 1); + + pthread_create(&thread2, NULL, (void *(*) (void *)) print_hello_world, (void *) 2); + + pthread_join(thread1, NULL); + pthread_join(thread2, NULL); + + MPI_Finalize(); + + SCOREP_USER_REGION_END( main_region ) + return; + +} diff --git a/test_selection/dorsal-lab_testcases/src/mpi_ssend_irecv.c b/test_selection/dorsal-lab_testcases/src/mpi_ssend_irecv.c new file mode 100755 index 0000000..d6b769a --- /dev/null +++ b/test_selection/dorsal-lab_testcases/src/mpi_ssend_irecv.c @@ -0,0 +1,54 @@ + #include + #include + #include + + /** + * @brief Illustrates how to wait for the completion of a non-blocking + * operation. + * @details This program is meant to be run with 2 processes: a sender and a + * receiver. + **/ + int main(int argc, char* argv[]) + { + MPI_Init(&argc, &argv); + + // Get the number of processes and check only 2 processes are used + int size; + MPI_Comm_size(MPI_COMM_WORLD, &size); + if(size != 2) + { + printf("This application is meant to be run with 2 processes.\n"); + MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); + } + + // Get my rank + int my_rank; + MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); + + if(my_rank == 0) + { + // The "master" MPI process sends the message. + int buffer = 12345; + printf("MPI process %d sends the value %d.\n", my_rank, buffer); + MPI_Ssend(&buffer, 1, MPI_INT, 1, 0, MPI_COMM_WORLD); + } + else + { + // The "slave" MPI process receives the message. + int received; + MPI_Request request; + MPI_Irecv(&received, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &request); + + // Do some other things while the underlying MPI_Recv progresses. + printf("MPI process %d issued the MPI_Irecv and moved on printing this message.\n", my_rank); + + // Wait for the MPI_Recv to complete. + printf("MPI process %d waits for the underlying MPI_Recv to complete.\n", my_rank); + MPI_Wait(&request, MPI_STATUS_IGNORE); + printf("The MPI_Wait completed, which means the underlying request (i.e: MPI_Recv) completed too.\n"); + } + + MPI_Finalize(); + + return EXIT_SUCCESS; + } diff --git a/test_selection/lambda_function_c++_factorial_of_12/bin11/bin11.cpp b/test_selection/lambda_function_c++_factorial_of_12/bin11/bin11.cpp new file mode 100755 index 0000000..c128c5f --- /dev/null +++ b/test_selection/lambda_function_c++_factorial_of_12/bin11/bin11.cpp @@ -0,0 +1,17 @@ +#include +#include + +int globVal = 12; + +auto wrapper_function = [](int n) +{ + std::function fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); }; + return fac(n); +}; + +int main() +{ + std::cout << "the factorial of " << globVal << " is " << wrapper_function(globVal) << "\n"; + return 0; +} + diff --git a/test_selection/lambda_function_c++_factorial_of_12/bin11/source.txt b/test_selection/lambda_function_c++_factorial_of_12/bin11/source.txt new file mode 100644 index 0000000..6783e76 --- /dev/null +++ b/test_selection/lambda_function_c++_factorial_of_12/bin11/source.txt @@ -0,0 +1 @@ +https://en.cppreference.com/w/cpp/utility/functional/function diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/MANIFEST.md b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/profile.cubex b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/profile.cubex new file mode 100644 index 0000000..ff1bb39 Binary files /dev/null and b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/profile.cubex differ diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/scorep.cfg b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.def b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.def new file mode 100644 index 0000000..67c3beb Binary files /dev/null and b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.def differ diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.otf2 b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.otf2 new file mode 100644 index 0000000..d4dc9ca Binary files /dev/null and b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces.otf2 differ diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.def b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.def new file mode 100644 index 0000000..7383359 Binary files /dev/null and b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.def differ diff --git a/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.evt b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.evt new file mode 100644 index 0000000..2f3ef51 Binary files /dev/null and b/test_selection/lambda_function_c++_factorial_of_12/scorep-20230904_1817_75078239523962/traces/0.evt differ diff --git a/test_selection/partdiff_runs/overview.txt b/test_selection/partdiff_runs/overview.txt new file mode 100755 index 0000000..9e3deee --- /dev/null +++ b/test_selection/partdiff_runs/overview.txt @@ -0,0 +1,57 @@ +Alle Runs: + 4096 Interlines + + + + +Run_1 - Run_3: + 10 Iterationen + 1 Node + + Run_1: + 4 Prozesse + 1 Thread + + Run_2: + 4 Prozesse + 4 Threads + + Run_3: + 16 Prozesse + 1 Thread + + + + +Run_4 - Run_6: + 10 Iterationen + + Run_4: + 4 Nodes + 4 Prozesse + 1 Thread + + Run_5: + 4 Nodes + 4 Prozesse + 4 Threads + + Run_6: + 7 Nodes (eine Node war allokiert, deshalb keine 8) + 16 Prozesse + 1 Thread + + + + +Run_7 - Run_8: + 1000 Iterationen + 1 Node + + Run_7: + 4 Prozesse + 4 Thread + + Run_8: + 16 Prozesse + 1 Threads \ No newline at end of file diff --git a/test_selection/partdiff_runs/run_1/output.txt b/test_selection/partdiff_runs/run_1/output.txt new file mode 100755 index 0000000..f142631 --- /dev/null +++ b/test_selection/partdiff_runs/run_1/output.txt @@ -0,0 +1,41 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 1 +Nodes: 1 +Tasks: 4 +Threads_per_task: 1 +Submitted batch job 419283 + + + + +Coverage Output +N: 32776 + +Process: 0 / 4 | Coverage-Indexes (S-E): 1 - 8195 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 1 / 4 | Coverage-Indexes (S-E): 8195 - 16389 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 2 / 4 | Coverage-Indexes (S-E): 16389 - 24583 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 3 / 4 | Coverage-Indexes (S-E): 24583 - 32776 | Covarage-Lines: 8193 | Covarage-Percantage: 24.9969 % + + +Berechnungszeit: 23.595408 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 8193.750000 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000124303255 0.0000000229682466 0.0000000300094604 0.0000000324820059 0.0000000300094604 0.0000000229682466 0.0000000124303255 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/MANIFEST.md b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/scorep.cfg b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.def b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.def new file mode 100755 index 0000000..14ac3cf Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.def differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.otf2 b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.otf2 new file mode 100755 index 0000000..3bf4c3e Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.def b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.def new file mode 100755 index 0000000..13637d5 Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.evt b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.evt new file mode 100755 index 0000000..ee1c589 Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.def b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.def new file mode 100755 index 0000000..0eef311 Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.evt b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.evt new file mode 100755 index 0000000..560276e Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.def b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.def new file mode 100755 index 0000000..60398fa Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.evt b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.evt new file mode 100755 index 0000000..d254bc7 Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.def b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.def new file mode 100755 index 0000000..afb973c Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.evt b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.evt new file mode 100755 index 0000000..17afc42 Binary files /dev/null and b/test_selection/partdiff_runs/run_1/scorep-20220521_1450_2462126659267749/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_2/output.txt b/test_selection/partdiff_runs/run_2/output.txt new file mode 100755 index 0000000..e0ac16a --- /dev/null +++ b/test_selection/partdiff_runs/run_2/output.txt @@ -0,0 +1,41 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 2 +Nodes: 1 +Tasks: 4 +Threads_per_task: 4 +Submitted batch job 419282 + + + + +Coverage Output +N: 32776 + +Process: 0 / 4 | Coverage-Indexes (S-E): 1 - 8195 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 1 / 4 | Coverage-Indexes (S-E): 8195 - 16389 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 2 / 4 | Coverage-Indexes (S-E): 16389 - 24583 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 3 / 4 | Coverage-Indexes (S-E): 24583 - 32776 | Covarage-Lines: 8193 | Covarage-Percantage: 24.9969 % + + +Berechnungszeit: 6.568493 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 8193.750000 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000124303255 0.0000000229682466 0.0000000300094604 0.0000000324820059 0.0000000300094604 0.0000000229682466 0.0000000124303255 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/MANIFEST.md b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/scorep.cfg b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.def new file mode 100755 index 0000000..07fe21b Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.otf2 b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.otf2 new file mode 100755 index 0000000..28353e3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.def new file mode 100755 index 0000000..bb78369 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.evt new file mode 100755 index 0000000..1f7ef7e Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.def new file mode 100755 index 0000000..9104378 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.evt new file mode 100755 index 0000000..91ee1d8 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.def new file mode 100755 index 0000000..bb78369 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.evt new file mode 100755 index 0000000..7f19456 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901888.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.def new file mode 100755 index 0000000..9104378 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.evt new file mode 100755 index 0000000..eced61f Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901889.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.def new file mode 100755 index 0000000..13b11f3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.evt new file mode 100755 index 0000000..0ae5cd7 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901890.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.def new file mode 100755 index 0000000..db902b3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.evt new file mode 100755 index 0000000..b7f3df0 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/12884901891.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.def new file mode 100755 index 0000000..13b11f3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.evt new file mode 100755 index 0000000..24e8f62 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.def new file mode 100755 index 0000000..db902b3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.evt new file mode 100755 index 0000000..8d54bfb Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.def new file mode 100755 index 0000000..bb78369 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.evt new file mode 100755 index 0000000..a7f7930 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967296.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.def new file mode 100755 index 0000000..9104378 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.evt new file mode 100755 index 0000000..42125b0 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967297.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.def new file mode 100755 index 0000000..13b11f3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.evt new file mode 100755 index 0000000..b3a7313 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967298.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.def new file mode 100755 index 0000000..db902b3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.evt new file mode 100755 index 0000000..25e9c15 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/4294967299.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.def new file mode 100755 index 0000000..bb78369 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.evt new file mode 100755 index 0000000..f7eff8b Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934592.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.def new file mode 100755 index 0000000..9104378 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.evt new file mode 100755 index 0000000..353d877 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934593.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.def new file mode 100755 index 0000000..13b11f3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.evt new file mode 100755 index 0000000..6827fc5 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934594.evt differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.def b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.def new file mode 100755 index 0000000..db902b3 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.def differ diff --git a/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.evt b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.evt new file mode 100755 index 0000000..ba39b54 Binary files /dev/null and b/test_selection/partdiff_runs/run_2/scorep-20220521_1449_2461899196337652/traces/8589934595.evt differ diff --git a/test_selection/partdiff_runs/run_3/output.txt b/test_selection/partdiff_runs/run_3/output.txt new file mode 100755 index 0000000..8cad183 --- /dev/null +++ b/test_selection/partdiff_runs/run_3/output.txt @@ -0,0 +1,53 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 3 +Nodes: 1 +Tasks: 16 +Threads_per_task: 1 +Submitted batch job 419284 + + + + +Coverage Output +N: 32776 + +Process: 0 / 16 | Coverage-Indexes (S-E): 1 - 2049 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 1 / 16 | Coverage-Indexes (S-E): 2049 - 4097 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 2 / 16 | Coverage-Indexes (S-E): 4097 - 6146 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 3 / 16 | Coverage-Indexes (S-E): 6146 - 8194 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 4 / 16 | Coverage-Indexes (S-E): 8194 - 10243 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 5 / 16 | Coverage-Indexes (S-E): 10243 - 12291 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 6 / 16 | Coverage-Indexes (S-E): 12291 - 14340 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 7 / 16 | Coverage-Indexes (S-E): 14340 - 16388 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 8 / 16 | Coverage-Indexes (S-E): 16388 - 18437 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 9 / 16 | Coverage-Indexes (S-E): 18437 - 20485 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 10 / 16 | Coverage-Indexes (S-E): 20485 - 22534 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 11 / 16 | Coverage-Indexes (S-E): 22534 - 24582 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 12 / 16 | Coverage-Indexes (S-E): 24582 - 26631 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 13 / 16 | Coverage-Indexes (S-E): 26631 - 28679 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 14 / 16 | Coverage-Indexes (S-E): 28679 - 30728 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 15 / 16 | Coverage-Indexes (S-E): 30728 - 32776 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % + + +Berechnungszeit: 6.400660 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 2048.437500 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067256870 0.0000000124274490 0.0000000162372447 0.0000000175750670 0.0000000162372447 0.0000000124274490 0.0000000067256870 0.0000000000000000 +0.0000000000000000 0.0000000124291340 0.0000000229660450 0.0000000300065839 0.0000000324788923 0.0000000300065839 0.0000000229660450 0.0000000124291340 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067288004 0.0000000124332019 0.0000000162447611 0.0000000175832027 0.0000000162447611 0.0000000124332019 0.0000000067288004 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/MANIFEST.md b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/scorep.cfg b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.def new file mode 100755 index 0000000..6faf27a Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.otf2 b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.otf2 new file mode 100755 index 0000000..570b3b7 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.def new file mode 100755 index 0000000..0be2031 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.evt new file mode 100755 index 0000000..5ba645c Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.def new file mode 100755 index 0000000..816664a Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.evt new file mode 100755 index 0000000..104f1c0 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.def new file mode 100755 index 0000000..db8dac4 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.evt new file mode 100755 index 0000000..011fa45 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/10.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.def new file mode 100755 index 0000000..4457d2e Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.evt new file mode 100755 index 0000000..1a7bcab Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/11.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.def new file mode 100755 index 0000000..e3b3bec Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.evt new file mode 100755 index 0000000..c97d1fa Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/12.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.def new file mode 100755 index 0000000..a4b1dce Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.evt new file mode 100755 index 0000000..9d4a939 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/13.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.def new file mode 100755 index 0000000..b3bdfd8 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.evt new file mode 100755 index 0000000..4a4ee16 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/14.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.def new file mode 100755 index 0000000..5ab43b4 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.evt new file mode 100755 index 0000000..da35a25 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/15.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.def new file mode 100755 index 0000000..aa54704 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.evt new file mode 100755 index 0000000..b99291d Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.def new file mode 100755 index 0000000..651ceba Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.evt new file mode 100755 index 0000000..4203059 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.def new file mode 100755 index 0000000..bf6dba0 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.evt new file mode 100755 index 0000000..8fee009 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/4.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.def new file mode 100755 index 0000000..c159dd7 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.evt new file mode 100755 index 0000000..e02e25d Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/5.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.def new file mode 100755 index 0000000..6ecc9fc Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.evt new file mode 100755 index 0000000..80ca588 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/6.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.def new file mode 100755 index 0000000..9709c6e Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.evt new file mode 100755 index 0000000..36c3b0a Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/7.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.def new file mode 100755 index 0000000..72e4b55 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.evt new file mode 100755 index 0000000..8e9a74c Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/8.evt differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.def b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.def new file mode 100755 index 0000000..e6b4669 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.def differ diff --git a/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.evt b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.evt new file mode 100755 index 0000000..ed36823 Binary files /dev/null and b/test_selection/partdiff_runs/run_3/scorep-20220521_1451_2462319294029945/traces/9.evt differ diff --git a/test_selection/partdiff_runs/run_4/output.txt b/test_selection/partdiff_runs/run_4/output.txt new file mode 100755 index 0000000..2810dd6 --- /dev/null +++ b/test_selection/partdiff_runs/run_4/output.txt @@ -0,0 +1,41 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 1 +Nodes: 4 +Tasks: 4 +Threads_per_task: 1 +Submitted batch job 419286 + + + + +Coverage Output +N: 32776 + +Process: 0 / 4 | Coverage-Indexes (S-E): 1 - 8195 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 1 / 4 | Coverage-Indexes (S-E): 8195 - 16389 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 2 / 4 | Coverage-Indexes (S-E): 16389 - 24583 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 3 / 4 | Coverage-Indexes (S-E): 24583 - 32776 | Covarage-Lines: 8193 | Covarage-Percantage: 24.9969 % + + +Berechnungszeit: 24.758664 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 8193.750000 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000124303255 0.0000000229682466 0.0000000300094604 0.0000000324820059 0.0000000300094604 0.0000000229682466 0.0000000124303255 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/MANIFEST.md b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/scorep.cfg b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.def b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.def new file mode 100755 index 0000000..ac77551 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.def differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.otf2 b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.otf2 new file mode 100755 index 0000000..eaec415 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.def b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.def new file mode 100755 index 0000000..600ad8b Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.evt b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.evt new file mode 100755 index 0000000..96fd231 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.def b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.def new file mode 100755 index 0000000..9e2c6de Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.evt b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.evt new file mode 100755 index 0000000..19bf43a Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.def b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.def new file mode 100755 index 0000000..c21c655 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.evt b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.evt new file mode 100755 index 0000000..bb65acf Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.def b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.def new file mode 100755 index 0000000..cfa6519 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.evt b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.evt new file mode 100755 index 0000000..72a6346 Binary files /dev/null and b/test_selection/partdiff_runs/run_4/scorep-20220521_1506_2464859351232707/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_5/output.txt b/test_selection/partdiff_runs/run_5/output.txt new file mode 100755 index 0000000..1e86e2c --- /dev/null +++ b/test_selection/partdiff_runs/run_5/output.txt @@ -0,0 +1,41 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 2 +Nodes: 4 +Tasks: 4 +Threads_per_task: 4 +Submitted batch job 419287 + + + + +Coverage Output +N: 32776 + +Process: 0 / 4 | Coverage-Indexes (S-E): 1 - 8195 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 1 / 4 | Coverage-Indexes (S-E): 8195 - 16389 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 2 / 4 | Coverage-Indexes (S-E): 16389 - 24583 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 3 / 4 | Coverage-Indexes (S-E): 24583 - 32776 | Covarage-Lines: 8193 | Covarage-Percantage: 24.9969 % + + +Berechnungszeit: 5.920003 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 8193.750000 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000124303255 0.0000000229682466 0.0000000300094604 0.0000000324820059 0.0000000300094604 0.0000000229682466 0.0000000124303255 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067272437 0.0000000124303255 0.0000000162410030 0.0000000175791349 0.0000000162410030 0.0000000124303255 0.0000000067272437 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/MANIFEST.md b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/scorep.cfg b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.def new file mode 100755 index 0000000..c3b88a7 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.otf2 b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.otf2 new file mode 100755 index 0000000..ef5289f Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.def new file mode 100755 index 0000000..f66e80e Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.evt new file mode 100755 index 0000000..b055683 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.def new file mode 100755 index 0000000..0f76483 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.evt new file mode 100755 index 0000000..a4f3ee3 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.def new file mode 100755 index 0000000..f66e80e Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.evt new file mode 100755 index 0000000..fe7a847 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901888.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.def new file mode 100755 index 0000000..0f76483 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.evt new file mode 100755 index 0000000..1d7eef4 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901889.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.def new file mode 100755 index 0000000..1040eae Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.evt new file mode 100755 index 0000000..a521abb Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901890.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.def new file mode 100755 index 0000000..36f43e6 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.evt new file mode 100755 index 0000000..ad09872 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/12884901891.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.def new file mode 100755 index 0000000..1040eae Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.evt new file mode 100755 index 0000000..a077114 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.def new file mode 100755 index 0000000..36f43e6 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.evt new file mode 100755 index 0000000..81fcbab Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.def new file mode 100755 index 0000000..f66e80e Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.evt new file mode 100755 index 0000000..c15f383 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967296.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.def new file mode 100755 index 0000000..0f76483 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.evt new file mode 100755 index 0000000..c7f3e9f Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967297.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.def new file mode 100755 index 0000000..1040eae Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.evt new file mode 100755 index 0000000..acd0a79 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967298.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.def new file mode 100755 index 0000000..36f43e6 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.evt new file mode 100755 index 0000000..148e968 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/4294967299.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.def new file mode 100755 index 0000000..f66e80e Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.evt new file mode 100755 index 0000000..090792b Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934592.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.def new file mode 100755 index 0000000..0f76483 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.evt new file mode 100755 index 0000000..1500748 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934593.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.def new file mode 100755 index 0000000..1040eae Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.evt new file mode 100755 index 0000000..f71a663 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934594.evt differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.def b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.def new file mode 100755 index 0000000..36f43e6 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.def differ diff --git a/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.evt b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.evt new file mode 100755 index 0000000..8626255 Binary files /dev/null and b/test_selection/partdiff_runs/run_5/scorep-20220521_1508_2465121453662016/traces/8589934595.evt differ diff --git a/test_selection/partdiff_runs/run_6/output.txt b/test_selection/partdiff_runs/run_6/output.txt new file mode 100755 index 0000000..5ff84c8 --- /dev/null +++ b/test_selection/partdiff_runs/run_6/output.txt @@ -0,0 +1,53 @@ +Interlines: 4096 +Iterations: 10 + +PARTDIFF_TEST_RUN: 3 +Nodes: 7 +Tasks: 16 +Threads_per_task: 1 +Submitted batch job 419289 + + + + +Coverage Output +N: 32776 + +Process: 0 / 16 | Coverage-Indexes (S-E): 1 - 2049 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 1 / 16 | Coverage-Indexes (S-E): 2049 - 4097 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 2 / 16 | Coverage-Indexes (S-E): 4097 - 6146 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 3 / 16 | Coverage-Indexes (S-E): 6146 - 8194 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 4 / 16 | Coverage-Indexes (S-E): 8194 - 10243 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 5 / 16 | Coverage-Indexes (S-E): 10243 - 12291 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 6 / 16 | Coverage-Indexes (S-E): 12291 - 14340 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 7 / 16 | Coverage-Indexes (S-E): 14340 - 16388 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 8 / 16 | Coverage-Indexes (S-E): 16388 - 18437 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 9 / 16 | Coverage-Indexes (S-E): 18437 - 20485 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 10 / 16 | Coverage-Indexes (S-E): 20485 - 22534 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 11 / 16 | Coverage-Indexes (S-E): 22534 - 24582 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 12 / 16 | Coverage-Indexes (S-E): 24582 - 26631 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 13 / 16 | Coverage-Indexes (S-E): 26631 - 28679 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 14 / 16 | Coverage-Indexes (S-E): 28679 - 30728 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 15 / 16 | Coverage-Indexes (S-E): 30728 - 32776 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % + + +Berechnungszeit: 6.072146 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 2048.437500 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 10 +Norm des Fehlers: 4.593649e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000000067256870 0.0000000124274490 0.0000000162372447 0.0000000175750670 0.0000000162372447 0.0000000124274490 0.0000000067256870 0.0000000000000000 +0.0000000000000000 0.0000000124291340 0.0000000229660450 0.0000000300065839 0.0000000324788923 0.0000000300065839 0.0000000229660450 0.0000000124291340 0.0000000000000000 +0.0000000000000000 0.0000000162403581 0.0000000300082688 0.0000000392076927 0.0000000424381008 0.0000000392076927 0.0000000300082688 0.0000000162403581 0.0000000000000000 +0.0000000000000000 0.0000000175791348 0.0000000324820058 0.0000000424397858 0.0000000459364931 0.0000000424397858 0.0000000324820058 0.0000000175791348 0.0000000000000000 +0.0000000000000000 0.0000000162416477 0.0000000300106517 0.0000000392108061 0.0000000424414707 0.0000000392108061 0.0000000300106517 0.0000000162416477 0.0000000000000000 +0.0000000000000000 0.0000000124315169 0.0000000229704481 0.0000000300123367 0.0000000324851192 0.0000000300123367 0.0000000229704481 0.0000000124315169 0.0000000000000000 +0.0000000000000000 0.0000000067288004 0.0000000124332019 0.0000000162447611 0.0000000175832027 0.0000000162447611 0.0000000124332019 0.0000000067288004 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/MANIFEST.md b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/scorep.cfg b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.def new file mode 100755 index 0000000..6570b7b Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.otf2 b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.otf2 new file mode 100755 index 0000000..c5c8115 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.def new file mode 100755 index 0000000..0475147 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.evt new file mode 100755 index 0000000..fe17e0f Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.def new file mode 100755 index 0000000..743251b Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.evt new file mode 100755 index 0000000..d991579 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.def new file mode 100755 index 0000000..0c49f23 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.evt new file mode 100755 index 0000000..215249c Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/10.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.def new file mode 100755 index 0000000..8b8fedd Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.evt new file mode 100755 index 0000000..f9c4a11 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/11.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.def new file mode 100755 index 0000000..9433755 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.evt new file mode 100755 index 0000000..72fe5c7 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/12.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.def new file mode 100755 index 0000000..61e84f4 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.evt new file mode 100755 index 0000000..86e0e1c Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/13.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.def new file mode 100755 index 0000000..4b2e0b3 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.evt new file mode 100755 index 0000000..76a62a5 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/14.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.def new file mode 100755 index 0000000..06fbcbf Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.evt new file mode 100755 index 0000000..b2bc0cf Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/15.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.def new file mode 100755 index 0000000..1ccf646 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.evt new file mode 100755 index 0000000..771a2f1 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.def new file mode 100755 index 0000000..6fc709c Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.evt new file mode 100755 index 0000000..2d65ce9 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.def new file mode 100755 index 0000000..fbd69f1 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.evt new file mode 100755 index 0000000..f1994fe Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/4.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.def new file mode 100755 index 0000000..266e724 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.evt new file mode 100755 index 0000000..80c2ed7 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/5.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.def new file mode 100755 index 0000000..93b8396 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.evt new file mode 100755 index 0000000..28f52e3 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/6.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.def new file mode 100755 index 0000000..096fc84 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.evt new file mode 100755 index 0000000..a6fe556 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/7.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.def new file mode 100755 index 0000000..238b60a Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.evt new file mode 100755 index 0000000..9302ee2 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/8.evt differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.def b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.def new file mode 100755 index 0000000..ca73cd8 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.def differ diff --git a/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.evt b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.evt new file mode 100755 index 0000000..aa30e69 Binary files /dev/null and b/test_selection/partdiff_runs/run_6/scorep-20220521_1511_2465707781233613/traces/9.evt differ diff --git a/test_selection/partdiff_runs/run_7/output.txt b/test_selection/partdiff_runs/run_7/output.txt new file mode 100755 index 0000000..c08c7ad --- /dev/null +++ b/test_selection/partdiff_runs/run_7/output.txt @@ -0,0 +1,41 @@ +Interlines: 4096 +Iterations: 1000 + +PARTDIFF_TEST_RUN: 2 +Nodes: 1 +Tasks: 4 +Threads_per_task: 4 +Submitted batch job 419281 + + + + +Coverage Output +N: 32776 + +Process: 0 / 4 | Coverage-Indexes (S-E): 1 - 8195 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 1 / 4 | Coverage-Indexes (S-E): 8195 - 16389 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 2 / 4 | Coverage-Indexes (S-E): 16389 - 24583 | Covarage-Lines: 8194 | Covarage-Percantage: 25.0000 % +Process: 3 / 4 | Coverage-Indexes (S-E): 24583 - 32776 | Covarage-Lines: 8193 | Covarage-Percantage: 24.9969 % + + +Berechnungszeit: 632.967125 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 8193.750000 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 1000 +Norm des Fehlers: 4.593628e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000006727228394 0.0000012430297247 0.0000016240966025 0.0000017579094951 0.0000016240966025 0.0000012430297247 0.0000006727228394 0.0000000000000000 +0.0000000000000000 0.0000012430297247 0.0000022968194419 0.0000030009392197 0.0000032481932050 0.0000030009392197 0.0000022968194419 0.0000012430297247 0.0000000000000000 +0.0000000000000000 0.0000016240321143 0.0000030008200611 0.0000039207603560 0.0000042438004286 0.0000039207603560 0.0000030008200611 0.0000016240321143 0.0000000000000000 +0.0000000000000000 0.0000017579094870 0.0000032481931901 0.0000042439689249 0.0000045936388626 0.0000042439689249 0.0000032481931901 0.0000017579094870 0.0000000000000000 +0.0000000000000000 0.0000016241610758 0.0000030010583508 0.0000039210716966 0.0000042441374212 0.0000039210716966 0.0000030010583508 0.0000016241610758 0.0000000000000000 +0.0000000000000000 0.0000012431488639 0.0000022970395824 0.0000030012268472 0.0000032485045307 0.0000030012268472 0.0000022970395824 0.0000012431488639 0.0000000000000000 +0.0000000000000000 0.0000006727228394 0.0000012430297247 0.0000016240966025 0.0000017579094951 0.0000016240966025 0.0000012430297247 0.0000006727228394 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/MANIFEST.md b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/scorep.cfg b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.def new file mode 100755 index 0000000..0c36529 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.otf2 b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.otf2 new file mode 100755 index 0000000..4082f9f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.def new file mode 100755 index 0000000..bf555f6 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.evt new file mode 100755 index 0000000..a47587a Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.def new file mode 100755 index 0000000..526215c Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.evt new file mode 100755 index 0000000..70786d4 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.def new file mode 100755 index 0000000..bf555f6 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.evt new file mode 100755 index 0000000..e85a1c7 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901888.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.def new file mode 100755 index 0000000..526215c Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.evt new file mode 100755 index 0000000..dcacf46 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901889.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.def new file mode 100755 index 0000000..add3967 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.evt new file mode 100755 index 0000000..57630df Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901890.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.def new file mode 100755 index 0000000..a79a89f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.evt new file mode 100755 index 0000000..7419222 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/12884901891.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.def new file mode 100755 index 0000000..add3967 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.evt new file mode 100755 index 0000000..697b175 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.def new file mode 100755 index 0000000..a79a89f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.evt new file mode 100755 index 0000000..f909810 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.def new file mode 100755 index 0000000..bf555f6 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.evt new file mode 100755 index 0000000..eeb7392 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967296.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.def new file mode 100755 index 0000000..526215c Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.evt new file mode 100755 index 0000000..af60ae8 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967297.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.def new file mode 100755 index 0000000..add3967 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.evt new file mode 100755 index 0000000..0cdc3ad Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967298.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.def new file mode 100755 index 0000000..a79a89f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.evt new file mode 100755 index 0000000..d759cf0 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/4294967299.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.def new file mode 100755 index 0000000..bf555f6 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.evt new file mode 100755 index 0000000..f5b0676 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934592.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.def new file mode 100755 index 0000000..526215c Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.evt new file mode 100755 index 0000000..455495f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934593.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.def new file mode 100755 index 0000000..add3967 Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.evt new file mode 100755 index 0000000..9f45fba Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934594.evt differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.def b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.def new file mode 100755 index 0000000..a79a89f Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.def differ diff --git a/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.evt b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.evt new file mode 100755 index 0000000..bfd357b Binary files /dev/null and b/test_selection/partdiff_runs/run_7/scorep-20220521_1441_2460597692341601/traces/8589934595.evt differ diff --git a/test_selection/partdiff_runs/run_8/output.txt b/test_selection/partdiff_runs/run_8/output.txt new file mode 100755 index 0000000..a72e13b --- /dev/null +++ b/test_selection/partdiff_runs/run_8/output.txt @@ -0,0 +1,53 @@ +Interlines: 4096 +Iterations: 1000 + +PARTDIFF_TEST_RUN: 3 +Nodes: 1 +Tasks: 16 +Threads_per_task: 1 +Submitted batch job 419285 + + + + +Coverage Output +N: 32776 + +Process: 0 / 16 | Coverage-Indexes (S-E): 1 - 2049 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 1 / 16 | Coverage-Indexes (S-E): 2049 - 4097 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 2 / 16 | Coverage-Indexes (S-E): 4097 - 6146 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 3 / 16 | Coverage-Indexes (S-E): 6146 - 8194 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 4 / 16 | Coverage-Indexes (S-E): 8194 - 10243 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 5 / 16 | Coverage-Indexes (S-E): 10243 - 12291 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 6 / 16 | Coverage-Indexes (S-E): 12291 - 14340 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 7 / 16 | Coverage-Indexes (S-E): 14340 - 16388 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 8 / 16 | Coverage-Indexes (S-E): 16388 - 18437 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 9 / 16 | Coverage-Indexes (S-E): 18437 - 20485 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 10 / 16 | Coverage-Indexes (S-E): 20485 - 22534 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 11 / 16 | Coverage-Indexes (S-E): 22534 - 24582 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 12 / 16 | Coverage-Indexes (S-E): 24582 - 26631 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 13 / 16 | Coverage-Indexes (S-E): 26631 - 28679 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % +Process: 14 / 16 | Coverage-Indexes (S-E): 28679 - 30728 | Covarage-Lines: 2049 | Covarage-Percantage: 6.2515 % +Process: 15 / 16 | Coverage-Indexes (S-E): 30728 - 32776 | Covarage-Lines: 2048 | Covarage-Percantage: 6.2485 % + + +Berechnungszeit: 638.058400 s +Speicherbedarf: 16393.001236 MiB +Avg. rows/process: 2048.437500 +Berechnungsmethode: Jacobi +Interlines: 4096 +Stoerfunktion: f(x,y) = 2 * pi^2 * sin(pi * x) * sin(pi * y) +Terminierung: Anzahl der Iterationen +Anzahl Iterationen: 1000 +Norm des Fehlers: 4.593628e-09 + +Matrix: +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 +0.0000000000000000 0.0000006725671660 0.0000012427420777 0.0000016237207737 0.0000017575027009 0.0000016237207737 0.0000012427420777 0.0000006725671660 0.0000000000000000 +0.0000000000000000 0.0000012429105741 0.0000022965992802 0.0000030006515647 0.0000032478818495 0.0000030006515647 0.0000022965992802 0.0000012429105741 0.0000000000000000 +0.0000000000000000 0.0000016240321143 0.0000030008200611 0.0000039207603560 0.0000042438004286 0.0000039207603560 0.0000030008200611 0.0000016240321143 0.0000000000000000 +0.0000000000000000 0.0000017579094870 0.0000032481931901 0.0000042439689249 0.0000045936388626 0.0000042439689249 0.0000032481931901 0.0000017579094870 0.0000000000000000 +0.0000000000000000 0.0000016241610758 0.0000030010583508 0.0000039210716966 0.0000042441374212 0.0000039210716966 0.0000030010583508 0.0000016241610758 0.0000000000000000 +0.0000000000000000 0.0000012431488639 0.0000022970395824 0.0000030012268472 0.0000032485045307 0.0000030012268472 0.0000022970395824 0.0000012431488639 0.0000000000000000 +0.0000000000000000 0.0000006728785066 0.0000012433173602 0.0000016244724164 0.0000017583162731 0.0000016244724164 0.0000012433173602 0.0000006728785066 0.0000000000000000 +0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/MANIFEST.md b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/MANIFEST.md new file mode 100755 index 0000000..67b6162 --- /dev/null +++ b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/MANIFEST.md @@ -0,0 +1,71 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_PROFILING + SCOREP_ENABLE_TRACING + SCOREP_VERBOSE + SCOREP_TOTAL_MEMORY + SCOREP_PAGE_SIZE + SCOREP_EXPERIMENT_DIRECTORY + SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY + SCOREP_MACHINE_NAME + SCOREP_EXECUTABLE + SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS + SCOREP_FORCE_CFG_FILES + SCOREP_TIMER + SCOREP_PROFILING_TASK_EXCHANGE_NUM + SCOREP_PROFILING_MAX_CALLPATH_DEPTH + SCOREP_PROFILING_BASE_NAME + SCOREP_PROFILING_FORMAT + SCOREP_PROFILING_ENABLE_CLUSTERING + SCOREP_PROFILING_CLUSTER_COUNT + SCOREP_PROFILING_CLUSTERING_MODE + SCOREP_PROFILING_CLUSTERED_REGION + SCOREP_PROFILING_ENABLE_CORE_FILES + SCOREP_TRACING_USE_SION + SCOREP_TRACING_MAX_PROCS_PER_SION_FILE + SCOREP_FILTERING_FILE + SCOREP_SUBSTRATE_PLUGINS + SCOREP_SUBSTRATE_PLUGINS_SEP + SCOREP_METRIC_PAPI + SCOREP_METRIC_PAPI_PER_PROCESS + SCOREP_METRIC_PAPI_SEP + SCOREP_METRIC_RUSAGE + SCOREP_METRIC_RUSAGE_PER_PROCESS + SCOREP_METRIC_RUSAGE_SEP + SCOREP_METRIC_PLUGINS + SCOREP_METRIC_PLUGINS_SEP + SCOREP_METRIC_PERF + SCOREP_METRIC_PERF_PER_PROCESS + SCOREP_METRIC_PERF_SEP + SCOREP_TOPOLOGY_PLATFORM + SCOREP_TOPOLOGY_PROCESS + SCOREP_TOPOLOGY_MPI + SCOREP_MEMORY_RECORDING + SCOREP_MPI_MAX_COMMUNICATORS + SCOREP_MPI_MAX_WINDOWS + SCOREP_MPI_MAX_EPOCHS + SCOREP_MPI_MAX_GROUPS + SCOREP_MPI_ENABLE_GROUPS + SCOREP_MPI_MEMORY_RECORDING + SCOREP_MPI_ONLINE_ANALYSIS diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/scorep.cfg b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/scorep.cfg new file mode 100755 index 0000000..7d4ef83 --- /dev/null +++ b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/scorep.cfg @@ -0,0 +1,48 @@ +SCOREP_ENABLE_PROFILING=false +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=30 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_PAPI='' +SCOREP_METRIC_PAPI_PER_PROCESS='' +SCOREP_METRIC_PAPI_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false +SCOREP_MPI_ONLINE_ANALYSIS=false diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.def new file mode 100755 index 0000000..85eaf26 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.otf2 b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.otf2 new file mode 100755 index 0000000..ad8999e Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces.otf2 differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.def new file mode 100755 index 0000000..9e811c6 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.evt new file mode 100755 index 0000000..eab73d9 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/0.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.def new file mode 100755 index 0000000..c176dc4 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.evt new file mode 100755 index 0000000..f94395f Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/1.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.def new file mode 100755 index 0000000..a2f56ae Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.evt new file mode 100755 index 0000000..db6b3c5 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/10.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.def new file mode 100755 index 0000000..541d5fd Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.evt new file mode 100755 index 0000000..6d293f1 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/11.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.def new file mode 100755 index 0000000..fc1284a Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.evt new file mode 100755 index 0000000..c2d4df9 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/12.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.def new file mode 100755 index 0000000..753cff2 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.evt new file mode 100755 index 0000000..600a5f2 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/13.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.def new file mode 100755 index 0000000..2ea48cc Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.evt new file mode 100755 index 0000000..8cc2d0c Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/14.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.def new file mode 100755 index 0000000..52d0e56 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.evt new file mode 100755 index 0000000..3a262aa Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/15.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.def new file mode 100755 index 0000000..a4bd4eb Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.evt new file mode 100755 index 0000000..7760676 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/2.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.def new file mode 100755 index 0000000..71a166a Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.evt new file mode 100755 index 0000000..321e3ef Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/3.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.def new file mode 100755 index 0000000..3a54d6a Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.evt new file mode 100755 index 0000000..bd89499 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/4.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.def new file mode 100755 index 0000000..ec2b65f Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.evt new file mode 100755 index 0000000..bf0bd37 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/5.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.def new file mode 100755 index 0000000..ce4fc7f Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.evt new file mode 100755 index 0000000..9ba166c Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/6.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.def new file mode 100755 index 0000000..a6cb8d5 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.evt new file mode 100755 index 0000000..9405b19 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/7.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.def new file mode 100755 index 0000000..ab3004c Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.evt new file mode 100755 index 0000000..0989ee4 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/8.evt differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.def b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.def new file mode 100755 index 0000000..4ccf742 Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.def differ diff --git a/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.evt b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.evt new file mode 100755 index 0000000..158470d Binary files /dev/null and b/test_selection/partdiff_runs/run_8/scorep-20220521_1503_2464310861616114/traces/9.evt differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7 b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7 new file mode 100755 index 0000000..6b6158e Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7 differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7.c b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7.c new file mode 100755 index 0000000..600da96 --- /dev/null +++ b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/bin7/bin7.c @@ -0,0 +1,7 @@ +#include + +int main() +{ + sleep(3600); + return 0; +} diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/MANIFEST.md b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/profile.cubex b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/profile.cubex new file mode 100644 index 0000000..357c66d Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/profile.cubex differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/scorep.cfg b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.def b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.def new file mode 100644 index 0000000..97e22fe Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.def differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.otf2 b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.otf2 new file mode 100644 index 0000000..492c011 Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces.otf2 differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.def b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.def new file mode 100644 index 0000000..66d7a19 Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.def differ diff --git a/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.evt b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.evt new file mode 100644 index 0000000..33b3b8b Binary files /dev/null and b/test_selection/pure_sleep_no_omp_no_mpi_one_hour/scorep-20230904_1329_14597518833887/traces/0.evt differ diff --git a/test_selection/rotating_donut_shape/SpinningDonut-master/README.md b/test_selection/rotating_donut_shape/SpinningDonut-master/README.md new file mode 100755 index 0000000..bfc01b3 --- /dev/null +++ b/test_selection/rotating_donut_shape/SpinningDonut-master/README.md @@ -0,0 +1,14 @@ +# SpinningDonut + +Donut code that renders a 3D spinning ASCII donut. + +## Usage: +```terminal +./main +``` + +![output](https://user-images.githubusercontent.com/46300167/206304169-f15cd658-7cdf-4a56-931c-9e0943c43f28.gif) + +## Links: +[Author GitHub](https://github.com/Martan03) +[Author website](https://martan03.github.io) diff --git a/test_selection/rotating_donut_shape/SpinningDonut-master/main.c b/test_selection/rotating_donut_shape/SpinningDonut-master/main.c new file mode 100755 index 0000000..4decd4f --- /dev/null +++ b/test_selection/rotating_donut_shape/SpinningDonut-master/main.c @@ -0,0 +1,23 @@ + #include + #include //OOOOOOOOO + #define at(x, y)(x + y * (W + 1))//O + int main(){int W=60,H=30,R;double r1=0.5,r2 + =1,k2=4.2,k1=W*k2*3/(8*(r1+r2)),PI=3.1415,rx=0// + ,rz=0,i=0,j=0,zb[H*W+H],cx,cy,x,y,z;char b[H*W+H];// + for(;;R++){printf("\x1b[0;0H");for(int i=0;i0){if(xp=0&&yp= + 0&&z>zb[at(xp,yp)]){zb[at(xp,yp)]=z;b[at(xp,yp)]= + ".,-:=*+*#%@"[(int)(lum*7.3)];}}}}fwrite(b,// + sizeof(b),1,stdout);rx+=0.006;rz+=// + 0.003;if(R>30)return 0;}} diff --git a/test_selection/rotating_donut_shape/SpinningDonut-master/small_modification_for_a_limited_runtime.jpg b/test_selection/rotating_donut_shape/SpinningDonut-master/small_modification_for_a_limited_runtime.jpg new file mode 100755 index 0000000..0cf4887 Binary files /dev/null and b/test_selection/rotating_donut_shape/SpinningDonut-master/small_modification_for_a_limited_runtime.jpg differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/bin4/bin4.c b/test_selection/small_trace_MPI_THREAD_MULTIPLE/bin4/bin4.c new file mode 100755 index 0000000..f6e1167 --- /dev/null +++ b/test_selection/small_trace_MPI_THREAD_MULTIPLE/bin4/bin4.c @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include + +void dummy_wrapper_sleep(int howlong) { + usleep(howlong); +} + +int main(int argc, char *argv[]){ + dummy_wrapper_sleep(250); + int numprocs, rank, namelen; + char processor_name[MPI_MAX_PROCESSOR_NAME]; + int provided; + //omp_lock_t lock; + + MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided); + + if (provided < MPI_THREAD_MULTIPLE) MPI_Abort(MPI_COMM_WORLD, 1); + + MPI_Comm_size(MPI_COMM_WORLD, &numprocs); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Get_processor_name(processor_name, &namelen); + + dummy_wrapper_sleep(250); + + // Rank 0 spawnt nichts... + if (rank != 0){ + // Nur soviele Threads wie die Rank-Nummer! + #pragma omp parallel num_threads(rank) + { + // Threadsnummer! + int iam = omp_get_thread_num(); + int np = omp_get_num_threads(); + + dummy_wrapper_sleep(iam*50); + printf("Thread %d# von %d Threads aus Prozess %d# von %d auf %s\n", iam, np, rank, numprocs, processor_name); + + int tag = rank * 10 + iam; + // Kritischer Bereich bzgl. MPI_Send (verworfen, Umstieg von 'serialized' auf 'multiple') + //omp_set_lock(&lock); + dummy_wrapper_sleep(iam*250); + MPI_Send(&iam, 1, MPI_INT, 0, tag, MPI_COMM_WORLD); + dummy_wrapper_sleep(iam*250); + //omp_unset_lock(&lock); + } + } + + MPI_Barrier(MPI_COMM_WORLD); + + + // Rank 0 ist alleine und emfängt und summiert + if (rank == 0){ + + dummy_wrapper_sleep(100); + int sum = 0; + // Wir grasen alle Prozesse/Ranks ab... + for (int i = 1; i < numprocs; i++){ + // ...und ihre Threads (Prozesse sind hier auch mitdabei als Mainthread) + for (int j = 0; j < i; j++){ + int threadnum; + MPI_Status status; + dummy_wrapper_sleep(100); + // Empfangen einer beliebigen Nachricht von einem beliebigen Prozess + MPI_Recv(&threadnum, 1, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status); + sum += threadnum; + printf("Zwischensumme: %d.\n", sum); + } + } + printf("Gesamtsumme: %d.\n", sum); // Ausgabe der Summe + } + + dummy_wrapper_sleep(500); + MPI_Finalize(); + //omp_destroy_lock(&lock); + return 0; +} + diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/MANIFEST.md b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/profile.cubex b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/profile.cubex new file mode 100644 index 0000000..33fd7eb Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/profile.cubex differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/scorep.cfg b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/scorep.cfg new file mode 100644 index 0000000..96ea384 --- /dev/null +++ b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/scorep.cfg @@ -0,0 +1,43 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.def new file mode 100644 index 0000000..9b5e1c8 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.otf2 b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.otf2 new file mode 100644 index 0000000..d345704 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces.otf2 differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.def new file mode 100644 index 0000000..fd430c5 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.evt new file mode 100644 index 0000000..c051bf7 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/0.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.def new file mode 100644 index 0000000..a800561 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.evt new file mode 100644 index 0000000..e9b3a02 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/1.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.def new file mode 100644 index 0000000..a629f64 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.evt new file mode 100644 index 0000000..72cf218 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/2.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.def new file mode 100644 index 0000000..8b4a62b Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.evt new file mode 100644 index 0000000..0acc7f4 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/3.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.def new file mode 100644 index 0000000..a629f64 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.evt new file mode 100644 index 0000000..ccfc804 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967298.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.def new file mode 100644 index 0000000..8b4a62b Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.evt new file mode 100644 index 0000000..4bf61f4 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/4294967299.evt differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.def b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.def new file mode 100644 index 0000000..8b4a62b Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.def differ diff --git a/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.evt b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.evt new file mode 100644 index 0000000..d921c80 Binary files /dev/null and b/test_selection/small_trace_MPI_THREAD_MULTIPLE/scorep-20230731_2337_38775329717664/traces/8589934595.evt differ diff --git a/test_selection/small_trace_custom_communicator/bin6.c b/test_selection/small_trace_custom_communicator/bin6.c new file mode 100755 index 0000000..f8ee670 --- /dev/null +++ b/test_selection/small_trace_custom_communicator/bin6.c @@ -0,0 +1,75 @@ +#include +#include +#include + +int main(int argc, char *argv[]) +{ + int rank, size; + int data; + int *recvbuf; + MPI_Group world_group, group_0; + MPI_Comm comm_0; + + // Init für MPI + MPI_Init(&argc, &argv); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &size); + + // Gruppe mit allen Ranks + MPI_Comm_group(MPI_COMM_WORLD, &world_group); + + // Gruppe aus Rank 0 und 1 + int n = 2; + int ranks[] = {0, 1}; + MPI_Group_incl(world_group, n, ranks, &group_0); + + // Kommunikator + MPI_Comm_create(MPI_COMM_WORLD, group_0, &comm_0); + + data = rank * 10; + + if (rank == 0 || rank == 1) + { + + // Ranks 0 und 1 bzw. Gruppe 0 macht eine kollektive Kommunikation + recvbuf = malloc(n * sizeof(int)); + MPI_Allgather(&data, 1, MPI_INT, recvbuf, 1, MPI_INT, comm_0); + + printf("Rank %d received: ", rank); + for (int i = 0; i < n; i++) + { + printf("%d ", recvbuf[i]); + } + printf("\n"); + + free(recvbuf); + MPI_Group_free(&group_0); + } + else if (rank == 2) + { + // P2P-Komm. von Rank 2 zu 3 + int dest = 3; + int tag = 0; + MPI_Send(&data, 1, MPI_INT, dest, tag, MPI_COMM_WORLD); + printf("Rank %d sent: %d to rank %d\n", rank, data, dest); + } + else if (rank == 3) + { + // P2P-Komm. von Rank 3 zu 2 + int source = 2; + int tag = 0; + MPI_Status status; + MPI_Recv(&data, 1, MPI_INT, source, tag, MPI_COMM_WORLD, &status); + printf("Rank %d received: %d from rank %d\n", rank, data, source); + } + else + { + printf("Rank %d did nothing\n", rank); + } + + MPI_Group_free(&world_group); + MPI_Finalize(); + + return 0; +} + diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/MANIFEST.md b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/MANIFEST.md new file mode 100755 index 0000000..0918bda --- /dev/null +++ b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/profile.cubex b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/profile.cubex new file mode 100755 index 0000000..ed7e94f Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/profile.cubex differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/scorep.cfg b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/scorep.cfg new file mode 100755 index 0000000..b1501d4 --- /dev/null +++ b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/scorep.cfg @@ -0,0 +1,44 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true +SCOREP_TOPOLOGY_MPI=true +SCOREP_MEMORY_RECORDING=false +SCOREP_MPI_MAX_COMMUNICATORS=50 +SCOREP_MPI_MAX_WINDOWS=50 +SCOREP_MPI_MAX_EPOCHS=50 +SCOREP_MPI_MAX_GROUPS=50 +SCOREP_MPI_ENABLE_GROUPS='cg','coll','env','io','p2p','rma','topo','xnonblock' +SCOREP_MPI_MEMORY_RECORDING=false diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.def b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.def new file mode 100755 index 0000000..17b996c Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.def differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.otf2 b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.otf2 new file mode 100755 index 0000000..cef6289 Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces.otf2 differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.def b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.def new file mode 100755 index 0000000..fa328b3 Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.def differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.evt b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.evt new file mode 100755 index 0000000..86bb0c2 Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/0.evt differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.def b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.def new file mode 100755 index 0000000..d1ecd89 Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.def differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.evt b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.evt new file mode 100755 index 0000000..a57b52d Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/1.evt differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.def b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.def new file mode 100755 index 0000000..f03d8eb Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.def differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.evt b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.evt new file mode 100755 index 0000000..31d8b35 Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/2.evt differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.def b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.def new file mode 100755 index 0000000..c0cfbbe Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.def differ diff --git a/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.evt b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.evt new file mode 100755 index 0000000..d13e0fa Binary files /dev/null and b/test_selection/small_trace_custom_communicator/scorep-20230828_2337_33833017943725/traces/3.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/bin3/bin3.c b/test_selection/small_trace_nested_parallel_region_no_mpi/bin3/bin3.c new file mode 100755 index 0000000..bc1e41d --- /dev/null +++ b/test_selection/small_trace_nested_parallel_region_no_mpi/bin3/bin3.c @@ -0,0 +1,26 @@ +#include +#include + +int main() { + omp_set_num_threads(2); + omp_set_nested(1); + + // Das ist unsere erste... + #pragma omp parallel + { + int id = omp_get_thread_num(); + printf("ThreadID: %d \n", id); + + omp_set_num_threads(3); + + // ...das die zweite parallele Region, *innerhalb* der ersten! + #pragma omp parallel + { + int id2 = omp_get_thread_num(); + + printf("ThreadID: %d ThreadID: %d \n", id, id2); + } + } + return 0; +} + diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/MANIFEST.md b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/profile.cubex b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/profile.cubex new file mode 100644 index 0000000..ad98c34 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/profile.cubex differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/scorep.cfg b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.def new file mode 100644 index 0000000..edf695f Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.otf2 b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.otf2 new file mode 100644 index 0000000..7e8af02 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces.otf2 differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.evt new file mode 100644 index 0000000..9aae676 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/0.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.evt new file mode 100644 index 0000000..0e3bd41 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/12884901888.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.evt new file mode 100644 index 0000000..117f2d7 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/17179869184.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.evt new file mode 100644 index 0000000..951d922 Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/21474836480.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.evt new file mode 100644 index 0000000..f1c842b Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/4294967296.evt differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.def b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.def new file mode 100644 index 0000000..8eaeeab Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.def differ diff --git a/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.evt b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.evt new file mode 100644 index 0000000..16d6c3f Binary files /dev/null and b/test_selection/small_trace_nested_parallel_region_no_mpi/scorep-20230805_2027_22340166434005/traces/8589934592.evt differ diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/bin5/bin5.c b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/bin5/bin5.c new file mode 100755 index 0000000..1451cf8 --- /dev/null +++ b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/bin5/bin5.c @@ -0,0 +1,5228 @@ +#include +#include +#include +#include + + +void color_000(){ + usleep(20); +} +void color_001(){ + usleep(20); +} +void color_002(){ + usleep(20); +} +void color_003(){ + usleep(20); +} +void color_004(){ + usleep(20); +} +void color_005(){ + usleep(20); +} +void color_006(){ + usleep(20); +} +void color_007(){ + usleep(20); +} +void color_008(){ + usleep(20); +} +void color_009(){ + usleep(20); +} +void color_010(){ + usleep(20); +} + +void color_011(){ + usleep(20); +} +void color_012(){ + usleep(20); +} +void color_013(){ + usleep(20); +} +void color_014(){ + usleep(20); +} +void color_015(){ + usleep(20); +} +void color_016(){ + usleep(20); +} +void color_017(){ + usleep(20); +} +void color_018(){ + usleep(20); +} +void color_019(){ + usleep(20); +} +void color_020(){ + usleep(20); +} + +void color_021(){ + usleep(20); +} +void color_022(){ + usleep(20); +} +void color_023(){ + usleep(20); +} +void color_024(){ + usleep(20); +} +void color_025(){ + usleep(20); +} +void color_026(){ + usleep(20); +} +void color_027(){ + usleep(20); +} +void color_028(){ + usleep(20); +} +void color_029(){ + usleep(20); +} +void color_030(){ + usleep(20); +} + +void color_031(){ + usleep(20); +} +void color_032(){ + usleep(20); +} +void color_033(){ + usleep(20); +} +void color_034(){ + usleep(20); +} +void color_035(){ + usleep(20); +} +void color_036(){ + usleep(20); +} +void color_037(){ + usleep(20); +} +void color_038(){ + usleep(20); +} +void color_039(){ + usleep(20); +} +void color_040(){ + usleep(20); +} + +void color_041(){ + usleep(20); +} +void color_042(){ + usleep(20); +} +void color_043(){ + usleep(20); +} +void color_044(){ + usleep(20); +} +void color_045(){ + usleep(20); +} +void color_046(){ + usleep(20); +} +void color_047(){ + usleep(20); +} +void color_048(){ + usleep(20); +} +void color_049(){ + usleep(20); +} +void color_050(){ + usleep(20); +} + +void color_051(){ + usleep(20); +} +void color_052(){ + usleep(20); +} +void color_053(){ + usleep(20); +} +void color_054(){ + usleep(20); +} +void color_055(){ + usleep(20); +} +void color_056(){ + usleep(20); +} +void color_057(){ + usleep(20); +} +void color_058(){ + usleep(20); +} +void color_059(){ + usleep(20); +} +void color_060(){ + usleep(20); +} + +void color_061(){ + usleep(20); +} +void color_062(){ + usleep(20); +} +void color_063(){ + usleep(20); +} +void color_064(){ + usleep(20); +} +void color_065(){ + usleep(20); +} +void color_066(){ + usleep(20); +} +void color_067(){ + usleep(20); +} +void color_068(){ + usleep(20); +} +void color_069(){ + usleep(20); +} +void color_070(){ + usleep(20); +} + +void color_071(){ + usleep(20); +} +void color_072(){ + usleep(20); +} +void color_073(){ + usleep(20); +} +void color_074(){ + usleep(20); +} +void color_075(){ + usleep(20); +} +void color_076(){ + usleep(20); +} +void color_077(){ + usleep(20); +} +void color_078(){ + usleep(20); +} +void color_079(){ + usleep(20); +} +void color_080(){ + usleep(20); +} + +void color_081(){ + usleep(20); +} +void color_082(){ + usleep(20); +} +void color_083(){ + usleep(20); +} +void color_084(){ + usleep(20); +} +void color_085(){ + usleep(20); +} +void color_086(){ + usleep(20); +} +void color_087(){ + usleep(20); +} +void color_088(){ + usleep(20); +} +void color_089(){ + usleep(20); +} +void color_090(){ + usleep(20); +} + +void color_091(){ + usleep(20); +} +void color_092(){ + usleep(20); +} +void color_093(){ + usleep(20); +} +void color_094(){ + usleep(20); +} +void color_095(){ + usleep(20); +} +void color_096(){ + usleep(20); +} +void color_097(){ + usleep(20); +} +void color_098(){ + usleep(20); +} +void color_099(){ + usleep(20); +} + +//------ +void color_100(){ + usleep(20); +} +void color_101(){ + usleep(20); +} +void color_102(){ + usleep(20); +} +void color_103(){ + usleep(20); +} +void color_104(){ + usleep(20); +} +void color_105(){ + usleep(20); +} +void color_106(){ + usleep(20); +} +void color_107(){ + usleep(20); +} +void color_108(){ + usleep(20); +} +void color_109(){ + usleep(20); +} +void color_110(){ + usleep(20); +} + +void color_111(){ + usleep(20); +} +void color_112(){ + usleep(20); +} +void color_113(){ + usleep(20); +} +void color_114(){ + usleep(20); +} +void color_115(){ + usleep(20); +} +void color_116(){ + usleep(20); +} +void color_117(){ + usleep(20); +} +void color_118(){ + usleep(20); +} +void color_119(){ + usleep(20); +} +void color_120(){ + usleep(20); +} + +void color_121(){ + usleep(20); +} +void color_122(){ + usleep(20); +} +void color_123(){ + usleep(20); +} +void color_124(){ + usleep(20); +} +void color_125(){ + usleep(20); +} +void color_126(){ + usleep(20); +} +void color_127(){ + usleep(20); +} +void color_128(){ + usleep(20); +} +void color_129(){ + usleep(20); +} +void color_130(){ + usleep(20); +} + +void color_131(){ + usleep(20); +} +void color_132(){ + usleep(20); +} +void color_133(){ + usleep(20); +} +void color_134(){ + usleep(20); +} +void color_135(){ + usleep(20); +} +void color_136(){ + usleep(20); +} +void color_137(){ + usleep(20); +} +void color_138(){ + usleep(20); +} +void color_139(){ + usleep(20); +} +void color_140(){ + usleep(20); +} + +void color_141(){ + usleep(20); +} +void color_142(){ + usleep(20); +} +void color_143(){ + usleep(20); +} +void color_144(){ + usleep(20); +} +void color_145(){ + usleep(20); +} +void color_146(){ + usleep(20); +} +void color_147(){ + usleep(20); +} +void color_148(){ + usleep(20); +} +void color_149(){ + usleep(20); +} +void color_150(){ + usleep(20); +} + +void color_151(){ + usleep(20); +} +void color_152(){ + usleep(20); +} +void color_153(){ + usleep(20); +} +void color_154(){ + usleep(20); +} +void color_155(){ + usleep(20); +} +void color_156(){ + usleep(20); +} +void color_157(){ + usleep(20); +} +void color_158(){ + usleep(20); +} +void color_159(){ + usleep(20); +} +void color_160(){ + usleep(20); +} + +void color_161(){ + usleep(20); +} +void color_162(){ + usleep(20); +} +void color_163(){ + usleep(20); +} +void color_164(){ + usleep(20); +} +void color_165(){ + usleep(20); +} +void color_166(){ + usleep(20); +} +void color_167(){ + usleep(20); +} +void color_168(){ + usleep(20); +} +void color_169(){ + usleep(20); +} +void color_170(){ + usleep(20); +} + +void color_171(){ + usleep(20); +} +void color_172(){ + usleep(20); +} +void color_173(){ + usleep(20); +} +void color_174(){ + usleep(20); +} +void color_175(){ + usleep(20); +} +void color_176(){ + usleep(20); +} +void color_177(){ + usleep(20); +} +void color_178(){ + usleep(20); +} +void color_179(){ + usleep(20); +} +void color_180(){ + usleep(20); +} + +void color_181(){ + usleep(20); +} +void color_182(){ + usleep(20); +} +void color_183(){ + usleep(20); +} +void color_184(){ + usleep(20); +} +void color_185(){ + usleep(20); +} +void color_186(){ + usleep(20); +} +void color_187(){ + usleep(20); +} +void color_188(){ + usleep(20); +} +void color_189(){ + usleep(20); +} +void color_190(){ + usleep(20); +} + +void color_191(){ + usleep(20); +} +void color_192(){ + usleep(20); +} +void color_193(){ + usleep(20); +} +void color_194(){ + usleep(20); +} +void color_195(){ + usleep(20); +} +void color_196(){ + usleep(20); +} +void color_197(){ + usleep(20); +} +void color_198(){ + usleep(20); +} +void color_199(){ + usleep(20); +} + +//------ +void color_200(){ + usleep(20); +} +void color_201(){ + usleep(20); +} +void color_202(){ + usleep(20); +} +void color_203(){ + usleep(20); +} +void color_204(){ + usleep(20); +} +void color_205(){ + usleep(20); +} +void color_206(){ + usleep(20); +} +void color_207(){ + usleep(20); +} +void color_208(){ + usleep(20); +} +void color_209(){ + usleep(20); +} +void color_210(){ + usleep(20); +} + +void color_211(){ + usleep(20); +} +void color_212(){ + usleep(20); +} +void color_213(){ + usleep(20); +} +void color_214(){ + usleep(20); +} +void color_215(){ + usleep(20); +} +void color_216(){ + usleep(20); +} +void color_217(){ + usleep(20); +} +void color_218(){ + usleep(20); +} +void color_219(){ + usleep(20); +} +void color_220(){ + usleep(20); +} + +void color_221(){ + usleep(20); +} +void color_222(){ + usleep(20); +} +void color_223(){ + usleep(20); +} +void color_224(){ + usleep(20); +} +void color_225(){ + usleep(20); +} +void color_226(){ + usleep(20); +} +void color_227(){ + usleep(20); +} +void color_228(){ + usleep(20); +} +void color_229(){ + usleep(20); +} +void color_230(){ + usleep(20); +} + +void color_231(){ + usleep(20); +} +void color_232(){ + usleep(20); +} +void color_233(){ + usleep(20); +} +void color_234(){ + usleep(20); +} +void color_235(){ + usleep(20); +} +void color_236(){ + usleep(20); +} +void color_237(){ + usleep(20); +} +void color_238(){ + usleep(20); +} +void color_239(){ + usleep(20); +} +void color_240(){ + usleep(20); +} + +void color_241(){ + usleep(20); +} +void color_242(){ + usleep(20); +} +void color_243(){ + usleep(20); +} +void color_244(){ + usleep(20); +} +void color_245(){ + usleep(20); +} +void color_246(){ + usleep(20); +} +void color_247(){ + usleep(20); +} +void color_248(){ + usleep(20); +} +void color_249(){ + usleep(20); +} +void color_250(){ + usleep(20); +} + +void color_251(){ + usleep(20); +} +void color_252(){ + usleep(20); +} +void color_253(){ + usleep(20); +} +void color_254(){ + usleep(20); +} +void color_255(){ + usleep(20); +} +void color_256(){ + usleep(20); +} +void color_257(){ + usleep(20); +} +void color_258(){ + usleep(20); +} +void color_259(){ + usleep(20); +} +void color_260(){ + usleep(20); +} + +void color_261(){ + usleep(20); +} +void color_262(){ + usleep(20); +} +void color_263(){ + usleep(20); +} +void color_264(){ + usleep(20); +} +void color_265(){ + usleep(20); +} +void color_266(){ + usleep(20); +} +void color_267(){ + usleep(20); +} +void color_268(){ + usleep(20); +} +void color_269(){ + usleep(20); +} +void color_270(){ + usleep(20); +} + +void color_271(){ + usleep(20); +} +void color_272(){ + usleep(20); +} +void color_273(){ + usleep(20); +} +void color_274(){ + usleep(20); +} +void color_275(){ + usleep(20); +} +void color_276(){ + usleep(20); +} +void color_277(){ + usleep(20); +} +void color_278(){ + usleep(20); +} +void color_279(){ + usleep(20); +} +void color_280(){ + usleep(20); +} + +void color_281(){ + usleep(20); +} +void color_282(){ + usleep(20); +} +void color_283(){ + usleep(20); +} +void color_284(){ + usleep(20); +} +void color_285(){ + usleep(20); +} +void color_286(){ + usleep(20); +} +void color_287(){ + usleep(20); +} +void color_288(){ + usleep(20); +} +void color_289(){ + usleep(20); +} +void color_290(){ + usleep(20); +} + +void color_291(){ + usleep(20); +} +void color_292(){ + usleep(20); +} +void color_293(){ + usleep(20); +} +void color_294(){ + usleep(20); +} +void color_295(){ + usleep(20); +} +void color_296(){ + usleep(20); +} +void color_297(){ + usleep(20); +} +void color_298(){ + usleep(20); +} +void color_299(){ + usleep(20); +} + +//------ +void color_300(){ + usleep(20); +} +void color_301(){ + usleep(20); +} +void color_302(){ + usleep(20); +} +void color_303(){ + usleep(20); +} +void color_304(){ + usleep(20); +} +void color_305(){ + usleep(20); +} +void color_306(){ + usleep(20); +} +void color_307(){ + usleep(20); +} +void color_308(){ + usleep(20); +} +void color_309(){ + usleep(20); +} +void color_310(){ + usleep(20); +} + +void color_311(){ + usleep(20); +} +void color_312(){ + usleep(20); +} +void color_313(){ + usleep(20); +} +void color_314(){ + usleep(20); +} +void color_315(){ + usleep(20); +} +void color_316(){ + usleep(20); +} +void color_317(){ + usleep(20); +} +void color_318(){ + usleep(20); +} +void color_319(){ + usleep(20); +} +void color_320(){ + usleep(20); +} + +void color_321(){ + usleep(20); +} +void color_322(){ + usleep(20); +} +void color_323(){ + usleep(20); +} +void color_324(){ + usleep(20); +} +void color_325(){ + usleep(20); +} +void color_326(){ + usleep(20); +} +void color_327(){ + usleep(20); +} +void color_328(){ + usleep(20); +} +void color_329(){ + usleep(20); +} +void color_330(){ + usleep(20); +} + +void color_331(){ + usleep(20); +} +void color_332(){ + usleep(20); +} +void color_333(){ + usleep(20); +} +void color_334(){ + usleep(20); +} +void color_335(){ + usleep(20); +} +void color_336(){ + usleep(20); +} +void color_337(){ + usleep(20); +} +void color_338(){ + usleep(20); +} +void color_339(){ + usleep(20); +} +void color_340(){ + usleep(20); +} + +void color_341(){ + usleep(20); +} +void color_342(){ + usleep(20); +} +void color_343(){ + usleep(20); +} +void color_344(){ + usleep(20); +} +void color_345(){ + usleep(20); +} +void color_346(){ + usleep(20); +} +void color_347(){ + usleep(20); +} +void color_348(){ + usleep(20); +} +void color_349(){ + usleep(20); +} +void color_350(){ + usleep(20); +} + +void color_351(){ + usleep(20); +} +void color_352(){ + usleep(20); +} +void color_353(){ + usleep(20); +} +void color_354(){ + usleep(20); +} +void color_355(){ + usleep(20); +} +void color_356(){ + usleep(20); +} +void color_357(){ + usleep(20); +} +void color_358(){ + usleep(20); +} +void color_359(){ + usleep(20); +} +void color_360(){ + usleep(20); +} + +void color_361(){ + usleep(20); +} +void color_362(){ + usleep(20); +} +void color_363(){ + usleep(20); +} +void color_364(){ + usleep(20); +} +void color_365(){ + usleep(20); +} +void color_366(){ + usleep(20); +} +void color_367(){ + usleep(20); +} +void color_368(){ + usleep(20); +} +void color_369(){ + usleep(20); +} +void color_370(){ + usleep(20); +} + +void color_371(){ + usleep(20); +} +void color_372(){ + usleep(20); +} +void color_373(){ + usleep(20); +} +void color_374(){ + usleep(20); +} +void color_375(){ + usleep(20); +} +void color_376(){ + usleep(20); +} +void color_377(){ + usleep(20); +} +void color_378(){ + usleep(20); +} +void color_379(){ + usleep(20); +} +void color_380(){ + usleep(20); +} + +void color_381(){ + usleep(20); +} +void color_382(){ + usleep(20); +} +void color_383(){ + usleep(20); +} +void color_384(){ + usleep(20); +} +void color_385(){ + usleep(20); +} +void color_386(){ + usleep(20); +} +void color_387(){ + usleep(20); +} +void color_388(){ + usleep(20); +} +void color_389(){ + usleep(20); +} +void color_390(){ + usleep(20); +} + +void color_391(){ + usleep(20); +} +void color_392(){ + usleep(20); +} +void color_393(){ + usleep(20); +} +void color_394(){ + usleep(20); +} +void color_395(){ + usleep(20); +} +void color_396(){ + usleep(20); +} +void color_397(){ + usleep(20); +} +void color_398(){ + usleep(20); +} +void color_399(){ + usleep(20); +} + +//------ +void color_400(){ + usleep(20); +} +void color_401(){ + usleep(20); +} +void color_402(){ + usleep(20); +} +void color_403(){ + usleep(20); +} +void color_404(){ + usleep(20); +} +void color_405(){ + usleep(20); +} +void color_406(){ + usleep(20); +} +void color_407(){ + usleep(20); +} +void color_408(){ + usleep(20); +} +void color_409(){ + usleep(20); +} +void color_410(){ + usleep(20); +} + +void color_411(){ + usleep(20); +} +void color_412(){ + usleep(20); +} +void color_413(){ + usleep(20); +} +void color_414(){ + usleep(20); +} +void color_415(){ + usleep(20); +} +void color_416(){ + usleep(20); +} +void color_417(){ + usleep(20); +} +void color_418(){ + usleep(20); +} +void color_419(){ + usleep(20); +} +void color_420(){ + usleep(20); +} + +void color_421(){ + usleep(20); +} +void color_422(){ + usleep(20); +} +void color_423(){ + usleep(20); +} +void color_424(){ + usleep(20); +} +void color_425(){ + usleep(20); +} +void color_426(){ + usleep(20); +} +void color_427(){ + usleep(20); +} +void color_428(){ + usleep(20); +} +void color_429(){ + usleep(20); +} +void color_430(){ + usleep(20); +} + +void color_431(){ + usleep(20); +} +void color_432(){ + usleep(20); +} +void color_433(){ + usleep(20); +} +void color_434(){ + usleep(20); +} +void color_435(){ + usleep(20); +} +void color_436(){ + usleep(20); +} +void color_437(){ + usleep(20); +} +void color_438(){ + usleep(20); +} +void color_439(){ + usleep(20); +} +void color_440(){ + usleep(20); +} + +void color_441(){ + usleep(20); +} +void color_442(){ + usleep(20); +} +void color_443(){ + usleep(20); +} +void color_444(){ + usleep(20); +} +void color_445(){ + usleep(20); +} +void color_446(){ + usleep(20); +} +void color_447(){ + usleep(20); +} +void color_448(){ + usleep(20); +} +void color_449(){ + usleep(20); +} +void color_450(){ + usleep(20); +} + +void color_451(){ + usleep(20); +} +void color_452(){ + usleep(20); +} +void color_453(){ + usleep(20); +} +void color_454(){ + usleep(20); +} +void color_455(){ + usleep(20); +} +void color_456(){ + usleep(20); +} +void color_457(){ + usleep(20); +} +void color_458(){ + usleep(20); +} +void color_459(){ + usleep(20); +} +void color_460(){ + usleep(20); +} + +void color_461(){ + usleep(20); +} +void color_462(){ + usleep(20); +} +void color_463(){ + usleep(20); +} +void color_464(){ + usleep(20); +} +void color_465(){ + usleep(20); +} +void color_466(){ + usleep(20); +} +void color_467(){ + usleep(20); +} +void color_468(){ + usleep(20); +} +void color_469(){ + usleep(20); +} +void color_470(){ + usleep(20); +} + +void color_471(){ + usleep(20); +} +void color_472(){ + usleep(20); +} +void color_473(){ + usleep(20); +} +void color_474(){ + usleep(20); +} +void color_475(){ + usleep(20); +} +void color_476(){ + usleep(20); +} +void color_477(){ + usleep(20); +} +void color_478(){ + usleep(20); +} +void color_479(){ + usleep(20); +} +void color_480(){ + usleep(20); +} + +void color_481(){ + usleep(20); +} +void color_482(){ + usleep(20); +} +void color_483(){ + usleep(20); +} +void color_484(){ + usleep(20); +} +void color_485(){ + usleep(20); +} +void color_486(){ + usleep(20); +} +void color_487(){ + usleep(20); +} +void color_488(){ + usleep(20); +} +void color_489(){ + usleep(20); +} +void color_490(){ + usleep(20); +} + +void color_491(){ + usleep(20); +} +void color_492(){ + usleep(20); +} +void color_493(){ + usleep(20); +} +void color_494(){ + usleep(20); +} +void color_495(){ + usleep(20); +} +void color_496(){ + usleep(20); +} +void color_497(){ + usleep(20); +} +void color_498(){ + usleep(20); +} +void color_499(){ + usleep(20); +} + +//------ +void color_500(){ + usleep(20); +} +void color_501(){ + usleep(20); +} +void color_502(){ + usleep(20); +} +void color_503(){ + usleep(20); +} +void color_504(){ + usleep(20); +} +void color_505(){ + usleep(20); +} +void color_506(){ + usleep(20); +} +void color_507(){ + usleep(20); +} +void color_508(){ + usleep(20); +} +void color_509(){ + usleep(20); +} +void color_510(){ + usleep(20); +} + +void color_511(){ + usleep(20); +} +void color_512(){ + usleep(20); +} +void color_513(){ + usleep(20); +} +void color_514(){ + usleep(20); +} +void color_515(){ + usleep(20); +} +void color_516(){ + usleep(20); +} +void color_517(){ + usleep(20); +} +void color_518(){ + usleep(20); +} +void color_519(){ + usleep(20); +} +void color_520(){ + usleep(20); +} + +void color_521(){ + usleep(20); +} +void color_522(){ + usleep(20); +} +void color_523(){ + usleep(20); +} +void color_524(){ + usleep(20); +} +void color_525(){ + usleep(20); +} +void color_526(){ + usleep(20); +} +void color_527(){ + usleep(20); +} +void color_528(){ + usleep(20); +} +void color_529(){ + usleep(20); +} +void color_530(){ + usleep(20); +} + +void color_531(){ + usleep(20); +} +void color_532(){ + usleep(20); +} +void color_533(){ + usleep(20); +} +void color_534(){ + usleep(20); +} +void color_535(){ + usleep(20); +} +void color_536(){ + usleep(20); +} +void color_537(){ + usleep(20); +} +void color_538(){ + usleep(20); +} +void color_539(){ + usleep(20); +} +void color_540(){ + usleep(20); +} + +void color_541(){ + usleep(20); +} +void color_542(){ + usleep(20); +} +void color_543(){ + usleep(20); +} +void color_544(){ + usleep(20); +} +void color_545(){ + usleep(20); +} +void color_546(){ + usleep(20); +} +void color_547(){ + usleep(20); +} +void color_548(){ + usleep(20); +} +void color_549(){ + usleep(20); +} +void color_550(){ + usleep(20); +} + +void color_551(){ + usleep(20); +} +void color_552(){ + usleep(20); +} +void color_553(){ + usleep(20); +} +void color_554(){ + usleep(20); +} +void color_555(){ + usleep(20); +} +void color_556(){ + usleep(20); +} +void color_557(){ + usleep(20); +} +void color_558(){ + usleep(20); +} +void color_559(){ + usleep(20); +} +void color_560(){ + usleep(20); +} + +void color_561(){ + usleep(20); +} +void color_562(){ + usleep(20); +} +void color_563(){ + usleep(20); +} +void color_564(){ + usleep(20); +} +void color_565(){ + usleep(20); +} +void color_566(){ + usleep(20); +} +void color_567(){ + usleep(20); +} +void color_568(){ + usleep(20); +} +void color_569(){ + usleep(20); +} +void color_570(){ + usleep(20); +} + +void color_571(){ + usleep(20); +} +void color_572(){ + usleep(20); +} +void color_573(){ + usleep(20); +} +void color_574(){ + usleep(20); +} +void color_575(){ + usleep(20); +} +void color_576(){ + usleep(20); +} +void color_577(){ + usleep(20); +} +void color_578(){ + usleep(20); +} +void color_579(){ + usleep(20); +} +void color_580(){ + usleep(20); +} + +void color_581(){ + usleep(20); +} +void color_582(){ + usleep(20); +} +void color_583(){ + usleep(20); +} +void color_584(){ + usleep(20); +} +void color_585(){ + usleep(20); +} +void color_586(){ + usleep(20); +} +void color_587(){ + usleep(20); +} +void color_588(){ + usleep(20); +} +void color_589(){ + usleep(20); +} +void color_590(){ + usleep(20); +} + +void color_591(){ + usleep(20); +} +void color_592(){ + usleep(20); +} +void color_593(){ + usleep(20); +} +void color_594(){ + usleep(20); +} +void color_595(){ + usleep(20); +} +void color_596(){ + usleep(20); +} +void color_597(){ + usleep(20); +} +void color_598(){ + usleep(20); +} +void color_599(){ + usleep(20); +} + +//------ +void color_600(){ + usleep(20); +} +void color_601(){ + usleep(20); +} +void color_602(){ + usleep(20); +} +void color_603(){ + usleep(20); +} +void color_604(){ + usleep(20); +} +void color_605(){ + usleep(20); +} +void color_606(){ + usleep(20); +} +void color_607(){ + usleep(20); +} +void color_608(){ + usleep(20); +} +void color_609(){ + usleep(20); +} +void color_610(){ + usleep(20); +} + +void color_611(){ + usleep(20); +} +void color_612(){ + usleep(20); +} +void color_613(){ + usleep(20); +} +void color_614(){ + usleep(20); +} +void color_615(){ + usleep(20); +} +void color_616(){ + usleep(20); +} +void color_617(){ + usleep(20); +} +void color_618(){ + usleep(20); +} +void color_619(){ + usleep(20); +} +void color_620(){ + usleep(20); +} + +void color_621(){ + usleep(20); +} +void color_622(){ + usleep(20); +} +void color_623(){ + usleep(20); +} +void color_624(){ + usleep(20); +} +void color_625(){ + usleep(20); +} +void color_626(){ + usleep(20); +} +void color_627(){ + usleep(20); +} +void color_628(){ + usleep(20); +} +void color_629(){ + usleep(20); +} +void color_630(){ + usleep(20); +} + +void color_631(){ + usleep(20); +} +void color_632(){ + usleep(20); +} +void color_633(){ + usleep(20); +} +void color_634(){ + usleep(20); +} +void color_635(){ + usleep(20); +} +void color_636(){ + usleep(20); +} +void color_637(){ + usleep(20); +} +void color_638(){ + usleep(20); +} +void color_639(){ + usleep(20); +} +void color_640(){ + usleep(20); +} + +void color_641(){ + usleep(20); +} +void color_642(){ + usleep(20); +} +void color_643(){ + usleep(20); +} +void color_644(){ + usleep(20); +} +void color_645(){ + usleep(20); +} +void color_646(){ + usleep(20); +} +void color_647(){ + usleep(20); +} +void color_648(){ + usleep(20); +} +void color_649(){ + usleep(20); +} +void color_650(){ + usleep(20); +} + +void color_651(){ + usleep(20); +} +void color_652(){ + usleep(20); +} +void color_653(){ + usleep(20); +} +void color_654(){ + usleep(20); +} +void color_655(){ + usleep(20); +} +void color_656(){ + usleep(20); +} +void color_657(){ + usleep(20); +} +void color_658(){ + usleep(20); +} +void color_659(){ + usleep(20); +} +void color_660(){ + usleep(20); +} + +void color_661(){ + usleep(20); +} +void color_662(){ + usleep(20); +} +void color_663(){ + usleep(20); +} +void color_664(){ + usleep(20); +} +void color_665(){ + usleep(20); +} +void color_666(){ + usleep(20); +} +void color_667(){ + usleep(20); +} +void color_668(){ + usleep(20); +} +void color_669(){ + usleep(20); +} +void color_670(){ + usleep(20); +} + +void color_671(){ + usleep(20); +} +void color_672(){ + usleep(20); +} +void color_673(){ + usleep(20); +} +void color_674(){ + usleep(20); +} +void color_675(){ + usleep(20); +} +void color_676(){ + usleep(20); +} +void color_677(){ + usleep(20); +} +void color_678(){ + usleep(20); +} +void color_679(){ + usleep(20); +} +void color_680(){ + usleep(20); +} + +void color_681(){ + usleep(20); +} +void color_682(){ + usleep(20); +} +void color_683(){ + usleep(20); +} +void color_684(){ + usleep(20); +} +void color_685(){ + usleep(20); +} +void color_686(){ + usleep(20); +} +void color_687(){ + usleep(20); +} +void color_688(){ + usleep(20); +} +void color_689(){ + usleep(20); +} +void color_690(){ + usleep(20); +} + +void color_691(){ + usleep(20); +} +void color_692(){ + usleep(20); +} +void color_693(){ + usleep(20); +} +void color_694(){ + usleep(20); +} +void color_695(){ + usleep(20); +} +void color_696(){ + usleep(20); +} +void color_697(){ + usleep(20); +} +void color_698(){ + usleep(20); +} +void color_699(){ + usleep(20); +} + +//------ +void color_700(){ + usleep(20); +} +void color_701(){ + usleep(20); +} +void color_702(){ + usleep(20); +} +void color_703(){ + usleep(20); +} +void color_704(){ + usleep(20); +} +void color_705(){ + usleep(20); +} +void color_706(){ + usleep(20); +} +void color_707(){ + usleep(20); +} +void color_708(){ + usleep(20); +} +void color_709(){ + usleep(20); +} +void color_710(){ + usleep(20); +} + +void color_711(){ + usleep(20); +} +void color_712(){ + usleep(20); +} +void color_713(){ + usleep(20); +} +void color_714(){ + usleep(20); +} +void color_715(){ + usleep(20); +} +void color_716(){ + usleep(20); +} +void color_717(){ + usleep(20); +} +void color_718(){ + usleep(20); +} +void color_719(){ + usleep(20); +} +void color_720(){ + usleep(20); +} + +void color_721(){ + usleep(20); +} +void color_722(){ + usleep(20); +} +void color_723(){ + usleep(20); +} +void color_724(){ + usleep(20); +} +void color_725(){ + usleep(20); +} +void color_726(){ + usleep(20); +} +void color_727(){ + usleep(20); +} +void color_728(){ + usleep(20); +} +void color_729(){ + usleep(20); +} +void color_730(){ + usleep(20); +} + +void color_731(){ + usleep(20); +} +void color_732(){ + usleep(20); +} +void color_733(){ + usleep(20); +} +void color_734(){ + usleep(20); +} +void color_735(){ + usleep(20); +} +void color_736(){ + usleep(20); +} +void color_737(){ + usleep(20); +} +void color_738(){ + usleep(20); +} +void color_739(){ + usleep(20); +} +void color_740(){ + usleep(20); +} + +void color_741(){ + usleep(20); +} +void color_742(){ + usleep(20); +} +void color_743(){ + usleep(20); +} +void color_744(){ + usleep(20); +} +void color_745(){ + usleep(20); +} +void color_746(){ + usleep(20); +} +void color_747(){ + usleep(20); +} +void color_748(){ + usleep(20); +} +void color_749(){ + usleep(20); +} +void color_750(){ + usleep(20); +} + +void color_751(){ + usleep(20); +} +void color_752(){ + usleep(20); +} +void color_753(){ + usleep(20); +} +void color_754(){ + usleep(20); +} +void color_755(){ + usleep(20); +} +void color_756(){ + usleep(20); +} +void color_757(){ + usleep(20); +} +void color_758(){ + usleep(20); +} +void color_759(){ + usleep(20); +} +void color_760(){ + usleep(20); +} + +void color_761(){ + usleep(20); +} +void color_762(){ + usleep(20); +} +void color_763(){ + usleep(20); +} +void color_764(){ + usleep(20); +} +void color_765(){ + usleep(20); +} +void color_766(){ + usleep(20); +} +void color_767(){ + usleep(20); +} +void color_768(){ + usleep(20); +} +void color_769(){ + usleep(20); +} +void color_770(){ + usleep(20); +} + +void color_771(){ + usleep(20); +} +void color_772(){ + usleep(20); +} +void color_773(){ + usleep(20); +} +void color_774(){ + usleep(20); +} +void color_775(){ + usleep(20); +} +void color_776(){ + usleep(20); +} +void color_777(){ + usleep(20); +} +void color_778(){ + usleep(20); +} +void color_779(){ + usleep(20); +} +void color_780(){ + usleep(20); +} + +void color_781(){ + usleep(20); +} +void color_782(){ + usleep(20); +} +void color_783(){ + usleep(20); +} +void color_784(){ + usleep(20); +} +void color_785(){ + usleep(20); +} +void color_786(){ + usleep(20); +} +void color_787(){ + usleep(20); +} +void color_788(){ + usleep(20); +} +void color_789(){ + usleep(20); +} +void color_790(){ + usleep(20); +} + +void color_791(){ + usleep(20); +} +void color_792(){ + usleep(20); +} +void color_793(){ + usleep(20); +} +void color_794(){ + usleep(20); +} +void color_795(){ + usleep(20); +} +void color_796(){ + usleep(20); +} +void color_797(){ + usleep(20); +} +void color_798(){ + usleep(20); +} +void color_799(){ + usleep(20); +} + +//------ +void color_800(){ + usleep(20); +} +void color_801(){ + usleep(20); +} +void color_802(){ + usleep(20); +} +void color_803(){ + usleep(20); +} +void color_804(){ + usleep(20); +} +void color_805(){ + usleep(20); +} +void color_806(){ + usleep(20); +} +void color_807(){ + usleep(20); +} +void color_808(){ + usleep(20); +} +void color_809(){ + usleep(20); +} +void color_810(){ + usleep(20); +} + +void color_811(){ + usleep(20); +} +void color_812(){ + usleep(20); +} +void color_813(){ + usleep(20); +} +void color_814(){ + usleep(20); +} +void color_815(){ + usleep(20); +} +void color_816(){ + usleep(20); +} +void color_817(){ + usleep(20); +} +void color_818(){ + usleep(20); +} +void color_819(){ + usleep(20); +} +void color_820(){ + usleep(20); +} + +void color_821(){ + usleep(20); +} +void color_822(){ + usleep(20); +} +void color_823(){ + usleep(20); +} +void color_824(){ + usleep(20); +} +void color_825(){ + usleep(20); +} +void color_826(){ + usleep(20); +} +void color_827(){ + usleep(20); +} +void color_828(){ + usleep(20); +} +void color_829(){ + usleep(20); +} +void color_830(){ + usleep(20); +} + +void color_831(){ + usleep(20); +} +void color_832(){ + usleep(20); +} +void color_833(){ + usleep(20); +} +void color_834(){ + usleep(20); +} +void color_835(){ + usleep(20); +} +void color_836(){ + usleep(20); +} +void color_837(){ + usleep(20); +} +void color_838(){ + usleep(20); +} +void color_839(){ + usleep(20); +} +void color_840(){ + usleep(20); +} + +void color_841(){ + usleep(20); +} +void color_842(){ + usleep(20); +} +void color_843(){ + usleep(20); +} +void color_844(){ + usleep(20); +} +void color_845(){ + usleep(20); +} +void color_846(){ + usleep(20); +} +void color_847(){ + usleep(20); +} +void color_848(){ + usleep(20); +} +void color_849(){ + usleep(20); +} +void color_850(){ + usleep(20); +} + +void color_851(){ + usleep(20); +} +void color_852(){ + usleep(20); +} +void color_853(){ + usleep(20); +} +void color_854(){ + usleep(20); +} +void color_855(){ + usleep(20); +} +void color_856(){ + usleep(20); +} +void color_857(){ + usleep(20); +} +void color_858(){ + usleep(20); +} +void color_859(){ + usleep(20); +} +void color_860(){ + usleep(20); +} + +void color_861(){ + usleep(20); +} +void color_862(){ + usleep(20); +} +void color_863(){ + usleep(20); +} +void color_864(){ + usleep(20); +} +void color_865(){ + usleep(20); +} +void color_866(){ + usleep(20); +} +void color_867(){ + usleep(20); +} +void color_868(){ + usleep(20); +} +void color_869(){ + usleep(20); +} +void color_870(){ + usleep(20); +} + +void color_871(){ + usleep(20); +} +void color_872(){ + usleep(20); +} +void color_873(){ + usleep(20); +} +void color_874(){ + usleep(20); +} +void color_875(){ + usleep(20); +} +void color_876(){ + usleep(20); +} +void color_877(){ + usleep(20); +} +void color_878(){ + usleep(20); +} +void color_879(){ + usleep(20); +} +void color_880(){ + usleep(20); +} + +void color_881(){ + usleep(20); +} +void color_882(){ + usleep(20); +} +void color_883(){ + usleep(20); +} +void color_884(){ + usleep(20); +} +void color_885(){ + usleep(20); +} +void color_886(){ + usleep(20); +} +void color_887(){ + usleep(20); +} +void color_888(){ + usleep(20); +} +void color_889(){ + usleep(20); +} +void color_890(){ + usleep(20); +} + +void color_891(){ + usleep(20); +} +void color_892(){ + usleep(20); +} +void color_893(){ + usleep(20); +} +void color_894(){ + usleep(20); +} +void color_895(){ + usleep(20); +} +void color_896(){ + usleep(20); +} +void color_897(){ + usleep(20); +} +void color_898(){ + usleep(20); +} +void color_899(){ + usleep(20); +} + +//------ +void color_900(){ + usleep(20); +} +void color_901(){ + usleep(20); +} +void color_902(){ + usleep(20); +} +void color_903(){ + usleep(20); +} +void color_904(){ + usleep(20); +} +void color_905(){ + usleep(20); +} +void color_906(){ + usleep(20); +} +void color_907(){ + usleep(20); +} +void color_908(){ + usleep(20); +} +void color_909(){ + usleep(20); +} +void color_910(){ + usleep(20); +} + +void color_911(){ + usleep(20); +} +void color_912(){ + usleep(20); +} +void color_913(){ + usleep(20); +} +void color_914(){ + usleep(20); +} +void color_915(){ + usleep(20); +} +void color_916(){ + usleep(20); +} +void color_917(){ + usleep(20); +} +void color_918(){ + usleep(20); +} +void color_919(){ + usleep(20); +} +void color_920(){ + usleep(20); +} + +void color_921(){ + usleep(20); +} +void color_922(){ + usleep(20); +} +void color_923(){ + usleep(20); +} +void color_924(){ + usleep(20); +} +void color_925(){ + usleep(20); +} +void color_926(){ + usleep(20); +} +void color_927(){ + usleep(20); +} +void color_928(){ + usleep(20); +} +void color_929(){ + usleep(20); +} +void color_930(){ + usleep(20); +} + +void color_931(){ + usleep(20); +} +void color_932(){ + usleep(20); +} +void color_933(){ + usleep(20); +} +void color_934(){ + usleep(20); +} +void color_935(){ + usleep(20); +} +void color_936(){ + usleep(20); +} +void color_937(){ + usleep(20); +} +void color_938(){ + usleep(20); +} +void color_939(){ + usleep(20); +} +void color_940(){ + usleep(20); +} + +void color_941(){ + usleep(20); +} +void color_942(){ + usleep(20); +} +void color_943(){ + usleep(20); +} +void color_944(){ + usleep(20); +} +void color_945(){ + usleep(20); +} +void color_946(){ + usleep(20); +} +void color_947(){ + usleep(20); +} +void color_948(){ + usleep(20); +} +void color_949(){ + usleep(20); +} +void color_950(){ + usleep(20); +} + +void color_951(){ + usleep(20); +} +void color_952(){ + usleep(20); +} +void color_953(){ + usleep(20); +} +void color_954(){ + usleep(20); +} +void color_955(){ + usleep(20); +} +void color_956(){ + usleep(20); +} +void color_957(){ + usleep(20); +} +void color_958(){ + usleep(20); +} +void color_959(){ + usleep(20); +} +void color_960(){ + usleep(20); +} + +void color_961(){ + usleep(20); +} +void color_962(){ + usleep(20); +} +void color_963(){ + usleep(20); +} +void color_964(){ + usleep(20); +} +void color_965(){ + usleep(20); +} +void color_966(){ + usleep(20); +} +void color_967(){ + usleep(20); +} +void color_968(){ + usleep(20); +} +void color_969(){ + usleep(20); +} +void color_970(){ + usleep(20); +} + +void color_971(){ + usleep(20); +} +void color_972(){ + usleep(20); +} +void color_973(){ + usleep(20); +} +void color_974(){ + usleep(20); +} +void color_975(){ + usleep(20); +} +void color_976(){ + usleep(20); +} +void color_977(){ + usleep(20); +} +void color_978(){ + usleep(20); +} +void color_979(){ + usleep(20); +} +void color_980(){ + usleep(20); +} + +void color_981(){ + usleep(20); +} +void color_982(){ + usleep(20); +} +void color_983(){ + usleep(20); +} +void color_984(){ + usleep(20); +} +void color_985(){ + usleep(20); +} +void color_986(){ + usleep(20); +} +void color_987(){ + usleep(20); +} +void color_988(){ + usleep(20); +} +void color_989(){ + usleep(20); +} +void color_990(){ + usleep(20); +} + +void color_991(){ + usleep(20); +} +void color_992(){ + usleep(20); +} +void color_993(){ + usleep(20); +} +void color_994(){ + usleep(20); +} +void color_995(){ + usleep(20); +} +void color_996(){ + usleep(20); +} +void color_997(){ + usleep(20); +} +void color_998(){ + usleep(20); +} +void color_999(){ + usleep(20); +} + + +int main(int argc, char *argv[]) { + + color_000(); + + color_001(); + + color_002(); + + color_003(); + + color_004(); + + color_005(); + + color_006(); + + color_007(); + + color_008(); + + color_009(); + + color_010(); + + + color_011(); + + color_012(); + + color_013(); + + color_014(); + + color_015(); + + color_016(); + + color_017(); + + color_018(); + + color_019(); + + color_020(); + + + color_021(); + + color_022(); + + color_023(); + + color_024(); + + color_025(); + + color_026(); + + color_027(); + + color_028(); + + color_029(); + + color_030(); + + + color_031(); + + color_032(); + + color_033(); + + color_034(); + + color_035(); + + color_036(); + + color_037(); + + color_038(); + + color_039(); + + color_040(); + + + color_041(); + + color_042(); + + color_043(); + + color_044(); + + color_045(); + + color_046(); + + color_047(); + + color_048(); + + color_049(); + + color_050(); + + + color_051(); + + color_052(); + + color_053(); + + color_054(); + + color_055(); + + color_056(); + + color_057(); + + color_058(); + + color_059(); + + color_060(); + + + color_061(); + + color_062(); + + color_063(); + + color_064(); + + color_065(); + + color_066(); + + color_067(); + + color_068(); + + color_069(); + + color_070(); + + + color_071(); + + color_072(); + + color_073(); + + color_074(); + + color_075(); + + color_076(); + + color_077(); + + color_078(); + + color_079(); + + color_080(); + + + color_081(); + + color_082(); + + color_083(); + + color_084(); + + color_085(); + + color_086(); + + color_087(); + + color_088(); + + color_089(); + + color_090(); + + + color_091(); + + color_092(); + + color_093(); + + color_094(); + + color_095(); + + color_096(); + + color_097(); + + color_098(); + + color_099(); + + + //------ + color_100(); + + color_101(); + + color_102(); + + color_103(); + + color_104(); + + color_105(); + + color_106(); + + color_107(); + + color_108(); + + color_109(); + + color_110(); + + + color_111(); + + color_112(); + + color_113(); + + color_114(); + + color_115(); + + color_116(); + + color_117(); + + color_118(); + + color_119(); + + color_120(); + + + color_121(); + + color_122(); + + color_123(); + + color_124(); + + color_125(); + + color_126(); + + color_127(); + + color_128(); + + color_129(); + + color_130(); + + + color_131(); + + color_132(); + + color_133(); + + color_134(); + + color_135(); + + color_136(); + + color_137(); + + color_138(); + + color_139(); + + color_140(); + + + color_141(); + + color_142(); + + color_143(); + + color_144(); + + color_145(); + + color_146(); + + color_147(); + + color_148(); + + color_149(); + + color_150(); + + + color_151(); + + color_152(); + + color_153(); + + color_154(); + + color_155(); + + color_156(); + + color_157(); + + color_158(); + + color_159(); + + color_160(); + + + color_161(); + + color_162(); + + color_163(); + + color_164(); + + color_165(); + + color_166(); + + color_167(); + + color_168(); + + color_169(); + + color_170(); + + + color_171(); + + color_172(); + + color_173(); + + color_174(); + + color_175(); + + color_176(); + + color_177(); + + color_178(); + + color_179(); + + color_180(); + + + color_181(); + + color_182(); + + color_183(); + + color_184(); + + color_185(); + + color_186(); + + color_187(); + + color_188(); + + color_189(); + + color_190(); + + + color_191(); + + color_192(); + + color_193(); + + color_194(); + + color_195(); + + color_196(); + + color_197(); + + color_198(); + + color_199(); + + + //------ + color_200(); + + color_201(); + + color_202(); + + color_203(); + + color_204(); + + color_205(); + + color_206(); + + color_207(); + + color_208(); + + color_209(); + + color_210(); + + + color_211(); + + color_212(); + + color_213(); + + color_214(); + + color_215(); + + color_216(); + + color_217(); + + color_218(); + + color_219(); + + color_220(); + + + color_221(); + + color_222(); + + color_223(); + + color_224(); + + color_225(); + + color_226(); + + color_227(); + + color_228(); + + color_229(); + + color_230(); + + + color_231(); + + color_232(); + + color_233(); + + color_234(); + + color_235(); + + color_236(); + + color_237(); + + color_238(); + + color_239(); + + color_240(); + + + color_241(); + + color_242(); + + color_243(); + + color_244(); + + color_245(); + + color_246(); + + color_247(); + + color_248(); + + color_249(); + + color_250(); + + + color_251(); + + color_252(); + + color_253(); + + color_254(); + + color_255(); + + color_256(); + + color_257(); + + color_258(); + + color_259(); + + color_260(); + + + color_261(); + + color_262(); + + color_263(); + + color_264(); + + color_265(); + + color_266(); + + color_267(); + + color_268(); + + color_269(); + + color_270(); + + + color_271(); + + color_272(); + + color_273(); + + color_274(); + + color_275(); + + color_276(); + + color_277(); + + color_278(); + + color_279(); + + color_280(); + + + color_281(); + + color_282(); + + color_283(); + + color_284(); + + color_285(); + + color_286(); + + color_287(); + + color_288(); + + color_289(); + + color_290(); + + + color_291(); + + color_292(); + + color_293(); + + color_294(); + + color_295(); + + color_296(); + + color_297(); + + color_298(); + + color_299(); + + + //------ + color_300(); + + color_301(); + + color_302(); + + color_303(); + + color_304(); + + color_305(); + + color_306(); + + color_307(); + + color_308(); + + color_309(); + + color_310(); + + + color_311(); + + color_312(); + + color_313(); + + color_314(); + + color_315(); + + color_316(); + + color_317(); + + color_318(); + + color_319(); + + color_320(); + + + color_321(); + + color_322(); + + color_323(); + + color_324(); + + color_325(); + + color_326(); + + color_327(); + + color_328(); + + color_329(); + + color_330(); + + + color_331(); + + color_332(); + + color_333(); + + color_334(); + + color_335(); + + color_336(); + + color_337(); + + color_338(); + + color_339(); + + color_340(); + + + color_341(); + + color_342(); + + color_343(); + + color_344(); + + color_345(); + + color_346(); + + color_347(); + + color_348(); + + color_349(); + + color_350(); + + + color_351(); + + color_352(); + + color_353(); + + color_354(); + + color_355(); + + color_356(); + + color_357(); + + color_358(); + + color_359(); + + color_360(); + + + color_361(); + + color_362(); + + color_363(); + + color_364(); + + color_365(); + + color_366(); + + color_367(); + + color_368(); + + color_369(); + + color_370(); + + + color_371(); + + color_372(); + + color_373(); + + color_374(); + + color_375(); + + color_376(); + + color_377(); + + color_378(); + + color_379(); + + color_380(); + + + color_381(); + + color_382(); + + color_383(); + + color_384(); + + color_385(); + + color_386(); + + color_387(); + + color_388(); + + color_389(); + + color_390(); + + + color_391(); + + color_392(); + + color_393(); + + color_394(); + + color_395(); + + color_396(); + + color_397(); + + color_398(); + + color_399(); + + + //------ + color_400(); + + color_401(); + + color_402(); + + color_403(); + + color_404(); + + color_405(); + + color_406(); + + color_407(); + + color_408(); + + color_409(); + + color_410(); + + + color_411(); + + color_412(); + + color_413(); + + color_414(); + + color_415(); + + color_416(); + + color_417(); + + color_418(); + + color_419(); + + color_420(); + + + color_421(); + + color_422(); + + color_423(); + + color_424(); + + color_425(); + + color_426(); + + color_427(); + + color_428(); + + color_429(); + + color_430(); + + + color_431(); + + color_432(); + + color_433(); + + color_434(); + + color_435(); + + color_436(); + + color_437(); + + color_438(); + + color_439(); + + color_440(); + + + color_441(); + + color_442(); + + color_443(); + + color_444(); + + color_445(); + + color_446(); + + color_447(); + + color_448(); + + color_449(); + + color_450(); + + + color_451(); + + color_452(); + + color_453(); + + color_454(); + + color_455(); + + color_456(); + + color_457(); + + color_458(); + + color_459(); + + color_460(); + + + color_461(); + + color_462(); + + color_463(); + + color_464(); + + color_465(); + + color_466(); + + color_467(); + + color_468(); + + color_469(); + + color_470(); + + + color_471(); + + color_472(); + + color_473(); + + color_474(); + + color_475(); + + color_476(); + + color_477(); + + color_478(); + + color_479(); + + color_480(); + + + color_481(); + + color_482(); + + color_483(); + + color_484(); + + color_485(); + + color_486(); + + color_487(); + + color_488(); + + color_489(); + + color_490(); + + + color_491(); + + color_492(); + + color_493(); + + color_494(); + + color_495(); + + color_496(); + + color_497(); + + color_498(); + + color_499(); + + + //------ + color_500(); + + color_501(); + + color_502(); + + color_503(); + + color_504(); + + color_505(); + + color_506(); + + color_507(); + + color_508(); + + color_509(); + + color_510(); + + + color_511(); + + color_512(); + + color_513(); + + color_514(); + + color_515(); + + color_516(); + + color_517(); + + color_518(); + + color_519(); + + color_520(); + + + color_521(); + + color_522(); + + color_523(); + + color_524(); + + color_525(); + + color_526(); + + color_527(); + + color_528(); + + color_529(); + + color_530(); + + + color_531(); + + color_532(); + + color_533(); + + color_534(); + + color_535(); + + color_536(); + + color_537(); + + color_538(); + + color_539(); + + color_540(); + + + color_541(); + + color_542(); + + color_543(); + + color_544(); + + color_545(); + + color_546(); + + color_547(); + + color_548(); + + color_549(); + + color_550(); + + + color_551(); + + color_552(); + + color_553(); + + color_554(); + + color_555(); + + color_556(); + + color_557(); + + color_558(); + + color_559(); + + color_560(); + + + color_561(); + + color_562(); + + color_563(); + + color_564(); + + color_565(); + + color_566(); + + color_567(); + + color_568(); + + color_569(); + + color_570(); + + + color_571(); + + color_572(); + + color_573(); + + color_574(); + + color_575(); + + color_576(); + + color_577(); + + color_578(); + + color_579(); + + color_580(); + + + color_581(); + + color_582(); + + color_583(); + + color_584(); + + color_585(); + + color_586(); + + color_587(); + + color_588(); + + color_589(); + + color_590(); + + + color_591(); + + color_592(); + + color_593(); + + color_594(); + + color_595(); + + color_596(); + + color_597(); + + color_598(); + + color_599(); + + + //------ + color_600(); + + color_601(); + + color_602(); + + color_603(); + + color_604(); + + color_605(); + + color_606(); + + color_607(); + + color_608(); + + color_609(); + + color_610(); + + + color_611(); + + color_612(); + + color_613(); + + color_614(); + + color_615(); + + color_616(); + + color_617(); + + color_618(); + + color_619(); + + color_620(); + + + color_621(); + + color_622(); + + color_623(); + + color_624(); + + color_625(); + + color_626(); + + color_627(); + + color_628(); + + color_629(); + + color_630(); + + + color_631(); + + color_632(); + + color_633(); + + color_634(); + + color_635(); + + color_636(); + + color_637(); + + color_638(); + + color_639(); + + color_640(); + + + color_641(); + + color_642(); + + color_643(); + + color_644(); + + color_645(); + + color_646(); + + color_647(); + + color_648(); + + color_649(); + + color_650(); + + + color_651(); + + color_652(); + + color_653(); + + color_654(); + + color_655(); + + color_656(); + + color_657(); + + color_658(); + + color_659(); + + color_660(); + + + color_661(); + + color_662(); + + color_663(); + + color_664(); + + color_665(); + + color_666(); + + color_667(); + + color_668(); + + color_669(); + + color_670(); + + + color_671(); + + color_672(); + + color_673(); + + color_674(); + + color_675(); + + color_676(); + + color_677(); + + color_678(); + + color_679(); + + color_680(); + + + color_681(); + + color_682(); + + color_683(); + + color_684(); + + color_685(); + + color_686(); + + color_687(); + + color_688(); + + color_689(); + + color_690(); + + + color_691(); + + color_692(); + + color_693(); + + color_694(); + + color_695(); + + color_696(); + + color_697(); + + color_698(); + + color_699(); + + + //------ + color_700(); + + color_701(); + + color_702(); + + color_703(); + + color_704(); + + color_705(); + + color_706(); + + color_707(); + + color_708(); + + color_709(); + + color_710(); + + + color_711(); + + color_712(); + + color_713(); + + color_714(); + + color_715(); + + color_716(); + + color_717(); + + color_718(); + + color_719(); + + color_720(); + + + color_721(); + + color_722(); + + color_723(); + + color_724(); + + color_725(); + + color_726(); + + color_727(); + + color_728(); + + color_729(); + + color_730(); + + + color_731(); + + color_732(); + + color_733(); + + color_734(); + + color_735(); + + color_736(); + + color_737(); + + color_738(); + + color_739(); + + color_740(); + + + color_741(); + + color_742(); + + color_743(); + + color_744(); + + color_745(); + + color_746(); + + color_747(); + + color_748(); + + color_749(); + + color_750(); + + + color_751(); + + color_752(); + + color_753(); + + color_754(); + + color_755(); + + color_756(); + + color_757(); + + color_758(); + + color_759(); + + color_760(); + + + color_761(); + + color_762(); + + color_763(); + + color_764(); + + color_765(); + + color_766(); + + color_767(); + + color_768(); + + color_769(); + + color_770(); + + + color_771(); + + color_772(); + + color_773(); + + color_774(); + + color_775(); + + color_776(); + + color_777(); + + color_778(); + + color_779(); + + color_780(); + + + color_781(); + + color_782(); + + color_783(); + + color_784(); + + color_785(); + + color_786(); + + color_787(); + + color_788(); + + color_789(); + + color_790(); + + + color_791(); + + color_792(); + + color_793(); + + color_794(); + + color_795(); + + color_796(); + + color_797(); + + color_798(); + + color_799(); + + + //------ + color_800(); + + color_801(); + + color_802(); + + color_803(); + + color_804(); + + color_805(); + + color_806(); + + color_807(); + + color_808(); + + color_809(); + + color_810(); + + + color_811(); + + color_812(); + + color_813(); + + color_814(); + + color_815(); + + color_816(); + + color_817(); + + color_818(); + + color_819(); + + color_820(); + + + color_821(); + + color_822(); + + color_823(); + + color_824(); + + color_825(); + + color_826(); + + color_827(); + + color_828(); + + color_829(); + + color_830(); + + + color_831(); + + color_832(); + + color_833(); + + color_834(); + + color_835(); + + color_836(); + + color_837(); + + color_838(); + + color_839(); + + color_840(); + + + color_841(); + + color_842(); + + color_843(); + + color_844(); + + color_845(); + + color_846(); + + color_847(); + + color_848(); + + color_849(); + + color_850(); + + + color_851(); + + color_852(); + + color_853(); + + color_854(); + + color_855(); + + color_856(); + + color_857(); + + color_858(); + + color_859(); + + color_860(); + + + color_861(); + + color_862(); + + color_863(); + + color_864(); + + color_865(); + + color_866(); + + color_867(); + + color_868(); + + color_869(); + + color_870(); + + + color_871(); + + color_872(); + + color_873(); + + color_874(); + + color_875(); + + color_876(); + + color_877(); + + color_878(); + + color_879(); + + color_880(); + + + color_881(); + + color_882(); + + color_883(); + + color_884(); + + color_885(); + + color_886(); + + color_887(); + + color_888(); + + color_889(); + + color_890(); + + + color_891(); + + color_892(); + + color_893(); + + color_894(); + + color_895(); + + color_896(); + + color_897(); + + color_898(); + + color_899(); + + + //------ + color_900(); + + color_901(); + + color_902(); + + color_903(); + + color_904(); + + color_905(); + + color_906(); + + color_907(); + + color_908(); + + color_909(); + + color_910(); + + + color_911(); + + color_912(); + + color_913(); + + color_914(); + + color_915(); + + color_916(); + + color_917(); + + color_918(); + + color_919(); + + color_920(); + + + color_921(); + + color_922(); + + color_923(); + + color_924(); + + color_925(); + + color_926(); + + color_927(); + + color_928(); + + color_929(); + + color_930(); + + + color_931(); + + color_932(); + + color_933(); + + color_934(); + + color_935(); + + color_936(); + + color_937(); + + color_938(); + + color_939(); + + color_940(); + + + color_941(); + + color_942(); + + color_943(); + + color_944(); + + color_945(); + + color_946(); + + color_947(); + + color_948(); + + color_949(); + + color_950(); + + + color_951(); + + color_952(); + + color_953(); + + color_954(); + + color_955(); + + color_956(); + + color_957(); + + color_958(); + + color_959(); + + color_960(); + + + color_961(); + + color_962(); + + color_963(); + + color_964(); + + color_965(); + + color_966(); + + color_967(); + + color_968(); + + color_969(); + + color_970(); + + + color_971(); + + color_972(); + + color_973(); + + color_974(); + + color_975(); + + color_976(); + + color_977(); + + color_978(); + + color_979(); + + color_980(); + + + color_981(); + + color_982(); + + color_983(); + + color_984(); + + color_985(); + + color_986(); + + color_987(); + + color_988(); + + color_989(); + + color_990(); + + + color_991(); + + color_992(); + + color_993(); + + color_994(); + + color_995(); + + color_996(); + + color_997(); + + color_998(); + + color_999(); + + return 0; +} diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/MANIFEST.md b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/profile.cubex b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/profile.cubex new file mode 100644 index 0000000..e9e04a2 Binary files /dev/null and b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/profile.cubex differ diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/scorep.cfg b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.def b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.def new file mode 100644 index 0000000..e4592d1 Binary files /dev/null and b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.def differ diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.otf2 b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.otf2 new file mode 100644 index 0000000..1cc0149 Binary files /dev/null and b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces.otf2 differ diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.def b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.def new file mode 100644 index 0000000..a47ff21 Binary files /dev/null and b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.def differ diff --git a/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.evt b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.evt new file mode 100644 index 0000000..e5c2b3a Binary files /dev/null and b/test_selection/small_trace_no_omp_no_mpi_thousand_functions/scorep-20230901_2231_26492689524019/traces/0.evt differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8 b/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8 new file mode 100755 index 0000000..e83b08c Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8 differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8.c b/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8.c new file mode 100755 index 0000000..7244593 --- /dev/null +++ b/test_selection/tiny_trace_function_runtime_fraction/bin8/bin8.c @@ -0,0 +1,50 @@ +#include +#include + +void func_10(){ + sleep(1); +} +void func_20(){ + sleep(2); +} +void func_30(){ + sleep(3); +} +void func_40(){ + sleep(4); +} + +int main() { + omp_set_num_threads(4); + + // Das ist unsere erste... + #pragma omp parallel + { + int id = omp_get_thread_num(); + if(id==0){ + func_10(); + func_20(); + func_30(); + func_40(); + } + if(id==1){ + func_20(); + func_20(); + func_30(); + func_30(); + } + if(id==2){ + func_20(); + func_20(); + func_20(); + func_40(); + } + if(id==3){ + func_20(); + func_40(); + func_40(); + } + } + return 0; +} + diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/MANIFEST.md b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/MANIFEST.md new file mode 100644 index 0000000..0918bda --- /dev/null +++ b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/MANIFEST.md @@ -0,0 +1,28 @@ +# Experiment directory overview + +The result directory of this measurement should contain the following files: + + 1. Files that should be present even if the measurement aborted: + + * `MANIFEST.md` This manifest file. + * `scorep.cfg` Listing of used environment variables. + + 2. Files that will be created by subsystems of the measurement core: + + * Tracing: + + * `traces.otf2` OTF2 anchor file. + * `traces.def` OTF2 global definitions file. + * `traces/` Sub-directory containing per location trace + data. + + * Profiling: + + * `profile.cubex` CUBE4 result file of the summary measurement. + +# List of Score-P variables that were explicitly set for this measurement + +The complete list of Score-P variables used, incl. current default values, +can be found in `scorep.cfg`. + + SCOREP_ENABLE_TRACING diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/profile.cubex b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/profile.cubex new file mode 100644 index 0000000..0d9e152 Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/profile.cubex differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/scorep.cfg b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/scorep.cfg new file mode 100644 index 0000000..6080703 --- /dev/null +++ b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/scorep.cfg @@ -0,0 +1,36 @@ +SCOREP_ENABLE_PROFILING=true +SCOREP_ENABLE_TRACING=true +SCOREP_VERBOSE=false +SCOREP_TOTAL_MEMORY=16000K +SCOREP_PAGE_SIZE=8K +SCOREP_EXPERIMENT_DIRECTORY='' +SCOREP_OVERWRITE_EXPERIMENT_DIRECTORY=true +SCOREP_MACHINE_NAME='Linux' +SCOREP_EXECUTABLE='' +SCOREP_ENABLE_SYSTEM_TREE_SEQUENCE_DEFINITIONS=false +SCOREP_FORCE_CFG_FILES=true +SCOREP_TIMER='tsc' +SCOREP_PROFILING_TASK_EXCHANGE_NUM=1K +SCOREP_PROFILING_MAX_CALLPATH_DEPTH=100 +SCOREP_PROFILING_BASE_NAME='profile' +SCOREP_PROFILING_FORMAT='cube4' +SCOREP_PROFILING_ENABLE_CLUSTERING=true +SCOREP_PROFILING_CLUSTER_COUNT=64 +SCOREP_PROFILING_CLUSTERING_MODE='subtree' +SCOREP_PROFILING_CLUSTERED_REGION='' +SCOREP_PROFILING_ENABLE_CORE_FILES=false +SCOREP_TRACING_USE_SION=false +SCOREP_TRACING_MAX_PROCS_PER_SION_FILE=1K +SCOREP_FILTERING_FILE='' +SCOREP_SUBSTRATE_PLUGINS='' +SCOREP_SUBSTRATE_PLUGINS_SEP=',' +SCOREP_METRIC_RUSAGE='' +SCOREP_METRIC_RUSAGE_PER_PROCESS='' +SCOREP_METRIC_RUSAGE_SEP=',' +SCOREP_METRIC_PLUGINS='' +SCOREP_METRIC_PLUGINS_SEP=',' +SCOREP_METRIC_PERF='' +SCOREP_METRIC_PERF_PER_PROCESS='' +SCOREP_METRIC_PERF_SEP=',' +SCOREP_TOPOLOGY_PLATFORM=true +SCOREP_TOPOLOGY_PROCESS=true diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.def b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.def new file mode 100644 index 0000000..cac658f Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.def differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.otf2 b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.otf2 new file mode 100644 index 0000000..bdd07e0 Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces.otf2 differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.def b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.def new file mode 100644 index 0000000..c732a6e Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.def differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.evt b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.evt new file mode 100644 index 0000000..b34a8f5 Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/0.evt differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.def b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.def new file mode 100644 index 0000000..c732a6e Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.def differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.evt b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.evt new file mode 100644 index 0000000..124e36a Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/12884901888.evt differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.def b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.def new file mode 100644 index 0000000..c732a6e Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.def differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.evt b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.evt new file mode 100644 index 0000000..c8328fa Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/4294967296.evt differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.def b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.def new file mode 100644 index 0000000..c732a6e Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.def differ diff --git a/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.evt b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.evt new file mode 100644 index 0000000..58267a7 Binary files /dev/null and b/test_selection/tiny_trace_function_runtime_fraction/scorep-20230904_1524_38570891228012/traces/8589934592.evt differ