X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a96adb51dabc0c759af11e60c770355f22a54ef3..cd4a6bff769c06de3840b08926eccf0734642f57:/src/instr/instr_private.hpp diff --git a/src/instr/instr_private.hpp b/src/instr/instr_private.hpp index 50a189a856..f860972ee9 100644 --- a/src/instr/instr_private.hpp +++ b/src/instr/instr_private.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2021. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -8,413 +8,268 @@ #include -#include "instr/instr_interface.h" #include "simgrid/instr.h" -#include "simgrid_config.h" -#include "src/internal_config.h" +#include "simgrid/s4u/Actor.hpp" +#include "src/instr/instr_paje_containers.hpp" +#include "src/instr/instr_paje_events.hpp" +#include "src/instr/instr_paje_types.hpp" +#include "src/instr/instr_paje_values.hpp" + +#include +#include /** std::setprecision **/ +#include #include +#include #include +#include #include -/* Need to define function drand48 for Windows */ -/* FIXME: use _drand48() defined in src/surf/random_mgr.c instead */ -#ifdef _WIN32 -# define drand48() (rand()/(RAND_MAX + 1.0)) -#endif - -#define INSTR_DEFAULT_STR_SIZE 500 - -#include "xbt/graph.h" -#include "xbt/dict.h" - namespace simgrid { namespace instr { -typedef enum { - PAJE_DefineContainerType, - PAJE_DefineVariableType, - PAJE_DefineStateType, - PAJE_DefineEventType, - PAJE_DefineLinkType, - PAJE_DefineEntityValue, - PAJE_CreateContainer, - PAJE_DestroyContainer, - PAJE_SetVariable, - PAJE_AddVariable, - PAJE_SubVariable, - PAJE_SetState, - PAJE_PushState, - PAJE_PopState, - PAJE_ResetState, - PAJE_StartLink, - PAJE_EndLink, - PAJE_NewEvent -} e_event_type; - -typedef enum { - TYPE_VARIABLE, - TYPE_LINK, - TYPE_CONTAINER, - TYPE_STATE, - TYPE_EVENT -} e_entity_types; - -//-------------------------------------------------- - -class Type { -public: - char* id_; - char* name_; - char* color_; - - e_entity_types kind_; - Type* father_; - xbt_dict_t children_; - xbt_dict_t values_; // valid for all types except variable and container - Type(const char* typeNameBuff, const char* key, const char* color, e_entity_types kind, Type* father); - ~Type(); - Type* getChild(const char* name); - Type* getChildOrNull(const char* name); - - static Type* containerNew(const char* name, Type* father); - static Type* eventNew(const char* name, Type* father); - static Type* variableNew(const char* name, const char* color, Type* father); - static Type* linkNew(const char* name, Type* father, Type* source, Type* dest); - static Type* stateNew(const char* name, Type* father); -}; +namespace paje { -//-------------------------------------------------- -class Value { -public: - char* id_; - char* name_; - char* color_; - - Type* father_; - Value(const char* name, const char* color, Type* father); - ~Value(); - static Value* get_or_new(const char* name, const char* color, Type* father); - static Value* get(const char* name, Type* father); -}; +void dump_generator_version(); +void dump_comment_file(const std::string& filename); +void dump_header(bool basic, bool display_sizes); +} // namespace paje -//-------------------------------------------------- -typedef enum { - INSTR_HOST, - INSTR_LINK, - INSTR_ROUTER, - INSTR_AS, - INSTR_SMPI, - INSTR_MSG_VM, - INSTR_MSG_PROCESS, - INSTR_MSG_TASK -} e_container_types; - -//-------------------------------------------------- - -class Container { -public: - Container(std::string name, simgrid::instr::e_container_types kind, Container* father); - virtual ~Container(); - - sg_netpoint_t netpoint_; - std::string name_; /* Unique name of this container */ - std::string id_; /* Unique id of this container */ - Type* type_; /* Type of this container */ - int level_ = 0; /* Level in the hierarchy, root level is 0 */ - e_container_types kind_; /* This container is of what kind */ - Container* father_; - std::map children_; -}; +/* Format of TRACING output. + * - paje is the regular format, that we all know + * - TI is a trick to reuse the tracing functions to generate a time independent trace during the execution. Such + * trace can easily be replayed with smpi_replay afterward. This trick should be removed and replaced by some code + * using the signal that we will create to cleanup the TRACING + */ +enum class TraceFormat { Paje, /*TimeIndependent*/ Ti }; +extern TraceFormat trace_format; +extern int trace_precision; +extern double last_timestamp_to_dump; -//-------------------------------------------------- -class PajeEvent { - public: - double timestamp_; - e_event_type eventType_; - virtual void print() = 0; - virtual ~PajeEvent(); -}; +void init(); +void define_callbacks(); -//-------------------------------------------------- -class SetVariableEvent : public PajeEvent { - private: - Container* container; - Type* type; - double value; +void platform_graph_export_graphviz(const std::string& output_filename); - public: - SetVariableEvent(double timestamp, Container* container, Type* type, double value); - void print() override; -}; +void resource_set_utilization(const char* type, const char* name, const char* resource, const std::string& category, + double value, double now, double delta); +void dump_buffer(bool force); -class AddVariableEvent:public PajeEvent { - private: - Container* container; - Type* type; - double value; +class TIData { + std::string name_; + double amount_ = 0; - public: - AddVariableEvent(double timestamp, Container* container, Type* type, double value); - void print() override; -}; -//-------------------------------------------------- +public: + explicit TIData(const std::string& name) : name_(name){}; + explicit TIData(const std::string& name, double amount) : name_(name), amount_(amount){}; + virtual ~TIData() = default; -class SubVariableEvent : public PajeEvent { - private: - Container* container; - Type* type; - double value; - public: - SubVariableEvent(double timestamp, Container* container, Type* type, double value); - void print() override; -}; -//-------------------------------------------------- - -class SetStateEvent : public PajeEvent { - private: - Container* container; - Type* type; - Value* value; - const char* filename; - int linenumber; - - public: - SetStateEvent(double timestamp, Container* container, Type* type, Value* val); - void print() override; + const std::string& get_name() const { return name_; } + double get_amount() const { return amount_; } + virtual std::string print() = 0; + virtual std::string display_size() = 0; }; +// NoOpTI: init, finalize, test, wait, barrier +class NoOpTIData : public TIData { + explicit NoOpTIData(const std::string&, double); // disallow this constructor inherited from TIData -class PushStateEvent : public PajeEvent { - public: - Container* container; - Type* type; - Value* value; - int size; - const char* filename; - int linenumber; - void* extra_; - - public: - PushStateEvent(double timestamp, Container* container, Type* type, Value* val); - PushStateEvent(double timestamp, Container* container, Type* type, Value* val, void* extra); - void print() override; +public: + using TIData::TIData; + std::string print() override { return get_name(); } + std::string display_size() override { return "NA"; } }; -class PopStateEvent : public PajeEvent { - Container* container; - Type* type; +// CPuTI: compute, sleep (+ waitAny and waitall out of laziness) +class CpuTIData : public TIData { + explicit CpuTIData(const std::string&); // disallow this constructor inherited from TIData public: - PopStateEvent(double timestamp, Container* container, Type* type); - void print() override; + using TIData::TIData; + std::string print() override + { + std::stringstream stream; + stream << get_name() << " " << get_amount(); + return stream.str(); + } + std::string display_size() override { return std::to_string(get_amount()); } }; -class ResetStateEvent : public PajeEvent { - Container* container; - Type* type; +// Pt2PtTI: send, isend, ssend, issend, recv, irecv +class Pt2PtTIData : public TIData { + int endpoint_; + size_t size_; + std::string type_; + int tag_ = 0; public: - ResetStateEvent(double timestamp, Container* container, Type* type); - void print() override; + Pt2PtTIData(const std::string& name, int endpoint, size_t size, const std::string& datatype) + : TIData(name), endpoint_(endpoint), size_(size), type_(datatype){}; + Pt2PtTIData(const std::string& name, int endpoint, size_t size, int tag, const std::string& datatype) + : TIData(name), endpoint_(endpoint), size_(size), type_(datatype), tag_(tag){}; + + std::string print() override + { + std::stringstream stream; + stream << get_name() << " " << endpoint_ << " " << tag_ << " " << size_ << " " << type_; + return stream.str(); + } + std::string display_size() override { return std::to_string(size_); } }; -class StartLinkEvent : public PajeEvent { - Container* container_; - Type* type_; - Container* sourceContainer_; - std::string value_; - std::string key_; - int size_; +// CollTI: bcast, reduce, allreduce, gather, scatter, allgather, alltoall +class CollTIData : public TIData { + int root_; + size_t send_size_; + size_t recv_size_; + std::string send_type_; + std::string recv_type_; public: - StartLinkEvent(double timestamp, Container* container, Type* type, Container* sourceContainer, const char* value, - const char* key); - StartLinkEvent(double timestamp, Container* container, Type* type, Container* sourceContainer, const char* value, - const char* key, int size); - void print() override; + CollTIData(const std::string& name, int root, double amount, size_t send_size, size_t recv_size, + const std::string& send_type, const std::string& recv_type) + : TIData(name, amount) + , root_(root) + , send_size_(send_size) + , recv_size_(recv_size) + , send_type_(send_type) + , recv_type_(recv_type){}; + + std::string print() override + { + std::stringstream stream; + stream << get_name() << " " << send_size_ << " "; + if (recv_size_ > 0) + stream << recv_size_ << " "; + if (get_amount() >= 0.0) + stream << get_amount() << " "; + if (root_ > 0 || (root_ == 0 && not send_type_.empty())) + stream << root_ << " "; + stream << send_type_ << " " << recv_type_; + + return stream.str(); + } + std::string display_size() override { return std::to_string(send_size_); } }; -class EndLinkEvent : public PajeEvent { - Container* container; - Type* type; - Container* destContainer; - std::string value; - std::string key; +// VarCollTI: gatherv, scatterv, allgatherv, alltoallv (+ reducescatter out of laziness) +class VarCollTIData : public TIData { + int root_; + long int send_size_; + std::shared_ptr> sendcounts_; + long int recv_size_; + std::shared_ptr> recvcounts_; + std::string send_type_; + std::string recv_type_; public: - EndLinkEvent(double timestamp, Container* container, Type* type, Container* destContainer, std::string value, - std::string key); - ~EndLinkEvent() = default; - void print() override; + VarCollTIData(const std::string& name, int root, long int send_size, std::shared_ptr> sendcounts, + long int recv_size, std::shared_ptr> recvcounts, const std::string& send_type, + const std::string& recv_type) + : TIData(name) + , root_(root) + , send_size_(send_size) + , sendcounts_(sendcounts) + , recv_size_(recv_size) + , recvcounts_(recvcounts) + , send_type_(send_type) + , recv_type_(recv_type){}; + + std::string print() override + { + std::stringstream stream; + stream << get_name() << " "; + if (send_size_ > -1) + stream << send_size_ << " "; + if (sendcounts_ != nullptr) + for (auto count : *sendcounts_) + stream << count << " "; + if (recv_size_ > -1) + stream << recv_size_ << " "; + if (recvcounts_ != nullptr) + for (auto count : *recvcounts_) + stream << count << " "; + if (root_ > 0 || (root_ == 0 && not send_type_.empty())) + stream << root_ << " "; + stream << send_type_ << " " << recv_type_; + + return stream.str(); + } + std::string display_size() override { return std::to_string(send_size_ > 0 ? send_size_ : recv_size_); } }; +/** + * If we want to wait for a request of asynchronous communication, we need to be able + * to identify this request. We do this by searching for a request identified by (src, dest, tag). + */ +class WaitTIData : public TIData { + int src_; + int dest_; + int tag_; -class NewEvent : public PajeEvent { - public: - Container* container; - Type* type; - Value* val; - - public: - NewEvent(double timestamp, Container* container, Type* type, Value* val); - void print() override; +public: + WaitTIData(int src, int dest, int tag) : TIData("wait"), src_(src), dest_(dest), tag_(tag){}; + + std::string print() override + { + std::stringstream stream; + stream << get_name() << " " << src_ << " " << dest_ << " " << tag_; + return stream.str(); + } + std::string display_size() override { return "NA"; } }; -} -} // namespace simgrid::instr -typedef simgrid::instr::Container* container_t; - -extern "C" { -extern XBT_PRIVATE std::set created_categories; -extern XBT_PRIVATE std::set declared_marks; -extern XBT_PRIVATE std::set user_host_variables; -extern XBT_PRIVATE std::set user_vm_variables; -extern XBT_PRIVATE std::set user_link_variables; -extern XBT_PRIVATE double TRACE_last_timestamp_to_dump; +class AmpiMigrateTIData : public TIData { + size_t memory_consumption_; -/* instr_paje_header.c */ -XBT_PRIVATE void TRACE_header(int basic, int size); +public: + explicit AmpiMigrateTIData(size_t memory_conso) : TIData("migrate"), memory_consumption_(memory_conso){}; + + std::string print() override + { + std::stringstream stream; + stream << get_name() << " " << memory_consumption_; + return stream.str(); + } + std::string display_size() override { return "NA"; } +}; +} // namespace instr +} // namespace simgrid -/* from paje.c */ -XBT_PRIVATE void TRACE_paje_start(); -XBT_PRIVATE void TRACE_paje_end(); -XBT_PRIVATE void TRACE_paje_dump_buffer (int force); +XBT_PRIVATE std::string instr_pid(simgrid::s4u::Actor const& proc); +extern XBT_PRIVATE std::set> created_categories; +extern XBT_PRIVATE std::set> declared_marks; +extern XBT_PRIVATE std::set> user_host_variables; +extern XBT_PRIVATE std::set> user_vm_variables; +extern XBT_PRIVATE std::set> user_link_variables; /* from instr_config.c */ -XBT_PRIVATE bool TRACE_needs_platform (); +XBT_PRIVATE bool TRACE_needs_platform(); XBT_PRIVATE bool TRACE_is_enabled(); XBT_PRIVATE bool TRACE_platform(); XBT_PRIVATE bool TRACE_platform_topology(); -XBT_PRIVATE bool TRACE_is_configured(); -XBT_PRIVATE bool TRACE_categorized (); -XBT_PRIVATE bool TRACE_uncategorized (); -XBT_PRIVATE bool TRACE_msg_process_is_enabled(); -XBT_PRIVATE bool TRACE_msg_vm_is_enabled(); -XBT_PRIVATE bool TRACE_buffer (); +XBT_PRIVATE bool TRACE_categorized(); +XBT_PRIVATE bool TRACE_uncategorized(); +XBT_PRIVATE bool TRACE_actor_is_enabled(); +XBT_PRIVATE bool TRACE_vm_is_enabled(); XBT_PRIVATE bool TRACE_disable_link(); XBT_PRIVATE bool TRACE_disable_speed(); -XBT_PRIVATE bool TRACE_onelink_only (); -XBT_PRIVATE bool TRACE_disable_destroy (); -XBT_PRIVATE bool TRACE_basic (); -XBT_PRIVATE bool TRACE_display_sizes (); -XBT_PRIVATE char *TRACE_get_comment (); -XBT_PRIVATE char *TRACE_get_comment_file (); -XBT_PRIVATE int TRACE_precision (); -XBT_PRIVATE char *TRACE_get_filename(); -XBT_PRIVATE char *TRACE_get_viva_uncat_conf (); -XBT_PRIVATE char *TRACE_get_viva_cat_conf (); -XBT_PRIVATE void TRACE_generate_viva_uncat_conf (); -XBT_PRIVATE void TRACE_generate_viva_cat_conf (); -XBT_PRIVATE void instr_pause_tracing (); -XBT_PRIVATE void instr_resume_tracing (); +XBT_PRIVATE bool TRACE_display_sizes(); /* Public functions used in SMPI */ -XBT_PUBLIC(bool) TRACE_smpi_is_enabled(); -XBT_PUBLIC(bool) TRACE_smpi_is_grouped(); -XBT_PUBLIC(bool) TRACE_smpi_is_computing(); -XBT_PUBLIC(bool) TRACE_smpi_is_sleeping(); -XBT_PUBLIC(bool) TRACE_smpi_view_internals(); - -/* from resource_utilization.c */ -XBT_PRIVATE void TRACE_surf_host_set_utilization(const char *resource, const char *category, double value, double now, - double delta); -XBT_PRIVATE void TRACE_surf_link_set_utilization(const char *resource,const char *category, double value, double now, - double delta); -XBT_PUBLIC(void) TRACE_surf_resource_utilization_alloc(); +XBT_PUBLIC bool TRACE_smpi_is_enabled(); +XBT_PUBLIC bool TRACE_smpi_is_grouped(); +XBT_PUBLIC bool TRACE_smpi_is_computing(); +XBT_PUBLIC bool TRACE_smpi_is_sleeping(); +XBT_PUBLIC bool TRACE_smpi_view_internals(); /* instr_paje.c */ -extern XBT_PRIVATE std::set trivaNodeTypes; -extern XBT_PRIVATE std::set trivaEdgeTypes; -XBT_PRIVATE long long int instr_new_paje_id (); -XBT_PUBLIC(container_t) PJ_container_get (const char *name); -XBT_PUBLIC(simgrid::instr::Container*) PJ_container_get_or_null(const char* name); -XBT_PUBLIC(container_t) PJ_container_get_root (); -XBT_PUBLIC(void) PJ_container_set_root (container_t root); -XBT_PUBLIC(void) PJ_container_remove_from_parent (container_t container); - -/* instr_paje_types.c */ -XBT_PUBLIC(simgrid::instr::Type*) PJ_type_get_root(); - -/* instr_config.c */ -XBT_PRIVATE void TRACE_TI_start(); -XBT_PRIVATE void TRACE_TI_end(); - -XBT_PRIVATE void TRACE_paje_dump_buffer (int force); -XBT_PRIVATE void dump_comment_file (const char *filename); -XBT_PRIVATE void dump_comment (const char *comment); - -struct s_instr_extra_data; -typedef struct s_instr_extra_data *instr_extra_data; - -typedef enum{ - TRACING_INIT, - TRACING_FINALIZE, - TRACING_COMM_SIZE, - TRACING_COMM_SPLIT, - TRACING_COMM_DUP, - TRACING_SEND, - TRACING_ISEND, - TRACING_SSEND, - TRACING_ISSEND, - TRACING_RECV, - TRACING_IRECV, - TRACING_SENDRECV, - TRACING_TEST, - TRACING_WAIT, - TRACING_WAITALL, - TRACING_WAITANY, - TRACING_BARRIER, - TRACING_BCAST, - TRACING_REDUCE, - TRACING_ALLREDUCE, - TRACING_ALLTOALL, - TRACING_ALLTOALLV, - TRACING_GATHER, - TRACING_GATHERV, - TRACING_SCATTER, - TRACING_SCATTERV, - TRACING_ALLGATHER, - TRACING_ALLGATHERV, - TRACING_REDUCE_SCATTER, - TRACING_COMPUTING, - TRACING_SLEEPING, - TRACING_SCAN, - TRACING_EXSCAN -} e_caller_type ; - -typedef struct s_instr_extra_data { - e_caller_type type; - int send_size; - int recv_size; - double comp_size; - double sleep_duration; - int src; - int dst; - int root; - const char* datatype1; - const char* datatype2; - int * sendcounts; - int * recvcounts; - int num_processes; -} s_instr_extra_data_t; +void instr_new_variable_type(const std::string& new_typename, const std::string& color); +void instr_new_user_variable_type(const std::string& parent_type, const std::string& new_typename, + const std::string& color); +void instr_new_user_state_type(const std::string& parent_type, const std::string& new_typename); +void instr_new_value_for_user_state_type(const std::string& new_typename, const char* value, const std::string& color); -/* Format of TRACING output. - * - paje is the regular format, that we all know - * - TI is a trick to reuse the tracing functions to generate a time independent trace during the execution. Such trace can easily be replayed with smpi_replay afterward. - * This trick should be removed and replaced by some code using the signal that we will create to cleanup the TRACING - */ -typedef enum { instr_fmt_paje, instr_fmt_TI } instr_fmt_type_t; -extern instr_fmt_type_t instr_fmt_type; -} - -void LogContainerTypeDefinition(simgrid::instr::Type* type); -void LogVariableTypeDefinition(simgrid::instr::Type* type); -void LogStateTypeDefinition(simgrid::instr::Type* type); -void LogLinkTypeDefinition(simgrid::instr::Type* type, simgrid::instr::Type* source, simgrid::instr::Type* dest); -void LogEntityValue(simgrid::instr::Value* val); -void LogContainerCreation (container_t container); -void LogContainerDestruction (container_t container); -void LogDefineEventType(simgrid::instr::Type* type); +XBT_PRIVATE void TRACE_help(); #endif