Logo Search packages:      
Sourcecode: s390-tools version File versions  Download package


 * FCP report generators
 * Class to hold information of a single frame.
 * Copyright IBM Corp. 2008
 * Author(s): Stefan Raspl <raspl@linux.vnet.ibm.com>


#include <list>
#include <vector>

#include "ziorep_collapser.hpp"

extern "C" {
      #include "ziomon_util.h"
      #include "blkiomon.h"
      #include "ziomon_zfcpdd.h"
      #include "ziomon_dacc.h"

using std::list;
using std::vector;

00028 class Frameset {

       * If 'normalize' is set, incoming data with varying sample
       * sizes per interval (namely utilization messages and zfcpdd data)
       * will be normalized so that different sample sizes will not
       * result in different weighting when aggregating.
      Frameset(const Collapser *col, bool normalize = true);

       * Clear frame-related structures */
      void reinit();

      /// get pointer to collapser
      const Collapser* get_collapser() const;

       * Since we don't necessarily have datasets for all messages in each
       * frame, utilization and the qdio portion of zfcpdd messages
       * can be inaccurate when aggregated. This method makes up for it by
       * calculating how many datasets are expected and fixing the data so
       * that mean values (and minima!) correctly reflect the frames with
       * inactivity.
       * 'interval_length' is the length of the intervals in the source data,
       * NOT any user-specified interval!
      void replace_missing_datasets(int interval_length);

       * Add structures to frame, automatically aggregates structures for
       * the same device if possible.
      void add_data(struct adapter_utilization *msg);
      void add_data(struct ioerr_cnt *msg);
      void add_data(struct blkiomon_stat *msg);
      void add_data(struct zfcpdd_dstat *msg);

       * Get start time of respective timeframe. This is the actually used
       * start time, which means that it is slightly earlier than the
       * expected start time so that messages that arrived slightly
       * earlier are included in this this rather than the previous frame. */
      __u64 get_begin_time() const;

      * Get end time of respective timeframe. This is the actually used
      * end time, which means that messages that arrived slightly
      * later than the prediced end time might still have been included
      * since they belong to this rather than to the next frame. */
      __u64 get_end_time() const;

      /* Get the timestamp of the frame. The timestamp
       * is the timestamp of the last message that was added to the frameset.
      __u64 get_timestamp() const;

       * Get duration of respective timeframe */
      __u64 get_duration() const;

       * Set begin and end of the interval, as well as the predicted
       * timestamp of the last interval where all the messages should have
       * arrived */
      void set_timeframe(__u64 begin, __u64 end, __u64 timestamp);

      /** Retrieve ioerr result.
       * WARNING: Memory ownership remains in class - copy if necessary!
      * FURTHER WARNING: Some of the pointers can be NULL!
      const vector<struct ioerr_cnt*>& get_ioerr_stats() const;

      /** Retrieve zfcpdd result.
      *  Can be NULL.
      const struct zfcpdd_dstat* get_first_zfcpdd_stat() const;

      /** Retrieve blkiomon result.
       *  Can be NULL.
      const struct blkiomon_stat* get_first_blkiomon_stat() const;

      const struct adapter_utilization* get_utilization_stat_by_host_id(__u32 h_id) const;

      const struct adapter_utilization* get_utilization_stat_by_chpid(__u32 chpid) const;

      const struct adapter_utilization* get_utilization_stat_by_devno(__u32 devno) const;

      const struct ioerr_cnt* get_ioerr_stat_by_chpid(__u32 chpid) const;

      const struct ioerr_cnt* get_ioerr_stat_by_devno(__u32 devno) const;

      const struct blkiomon_stat* get_blkiomon_stat_by_chpid(__u32 chpid) const;

      const struct blkiomon_stat* get_blkiomon_stat_by_devno(__u32 devno) const;

      const struct blkiomon_stat* get_blkiomon_stat_by_wwpn(__u64 wwpn) const;

      const struct blkiomon_stat* get_blkiomon_stat_by_mp_mm(__u32 mp_mm) const;

      const struct blkiomon_stat* get_blkiomon_stat_by_mm(__u32 mm) const;

      const struct zfcpdd_dstat* get_zfcpdd_stat_by_chpid(__u32 chpid) const;

      const struct zfcpdd_dstat* get_zfcpdd_stat_by_devno(__u32 devno) const;

      const struct zfcpdd_dstat* get_zfcpdd_stat_by_wwpn(__u64 wwpn) const;

      const struct zfcpdd_dstat* get_zfcpdd_stat_by_mp_mm(__u32 mp_mm) const;

      const struct zfcpdd_dstat* get_zfcpdd_stat_by_mm(__u32 mm) const;

      void set_aggregated(bool aggr);

      /** Is the frameset built from the .agg file? */
      bool is_aggregated() const;

      /** Query whether the frameset holds data or not */
      bool is_empty() const;

00152       struct utilization_wrapper {
            /// number aggregated datasets
00154             int                      counter;
            struct adapter_utilization    *stat;

00158       struct zfcpdd_wrapper {
            /// number aggregated datasets
00160             int                counter;
            struct zfcpdd_dstat     *stat;

      bool m_empty;

      void normalize_util_stat(struct utilization_stats *stats);

      void normalize_stat(struct abbrev_stat *stat, __u64 count);

      /// rescale zfcpdd_dstat->channel_latency from ns to us
      void normalize_zfcpdd_stat(struct zfcpdd_dstat *stat);

      void init_utilization_wrapper(struct utilization_wrapper *wrp);

      void init_zfcpdd_wrapper(struct zfcpdd_wrapper *wrp);

      void add_zero_frames(struct utilization_wrapper *wrp,
                       int num_expected, int interval_length);

      int get_by_chpid(__u32 chpid) const;

      int get_by_devno(__u32 devno) const;

      int get_by_mp_mm(__u32 mp_mm) const;

      int get_by_mm(__u32 mm) const;

      int get_by_wwpn(__u64 wwpn) const;

      /// returns index of 'val' as found in 'lst', <0 otherwise
      int find_index(const list<__u32> &lst, __u32 val) const;

      /// returns index of 'val' as found in 'lst', <0 otherwise
      int find_index(const list<__u64> &lst, __u64 val) const;

      /// zfcpdd statistics, ordered by host adapter no (ascending)
00198       vector<struct utilization_wrapper>  m_util_stats;

      /** ioerror stats, ordered by device identifiers
       * (hierarchical & ascending) */
00202       vector<struct ioerr_cnt*>           m_ioerr_stats;

      /// zfcpdd statistics, ordered by device (ascending)
00205       vector<struct zfcpdd_wrapper>       m_zfcpdd_stats;
      /// zfcpdd statistics, ordered by device (ascending)
00207       vector<struct blkiomon_stat*>       m_blkiomon_stats;
      /// begin of the frame
00209       __u64                         m_start_time;
      /// end of the frame
00211       __u64                         m_end_time;
      /// timestamp of latest message added to the set
00213       __u64                         m_timestamp;
      /// indicates whether the frameset is from the .agg file
00215       bool                          m_aggregated;

      /** provides translation from data objects to (vector) index
        * This member is kept throughout, even survives calls to reinit(). */
00219       const Collapser                      *m_collapser;

      /** normalize all incoming datasets so they are equally weighted
       * when aggregating over multiple frames */
00223       bool                          m_normalize;


Generated by  Doxygen 1.6.0   Back to index