src/Statistics.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 // Copyright (C) 2005-2008 Dévai Tamás ( gonosztopi@amule.org )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #ifndef STATISTICS_H
  28 #define STATISTICS_H
  29
  30 #include "StatTree.h"           // Needed for CStatTreeItem* classes
  31 #include "GetTickCount.h"       // Needed for GetTickCount64()
  32
  33 #include <deque>                // Needed for std::deque
  34
  35 enum StatsGraphType {
  36         GRAPH_INVALID = 0,
  37         GRAPH_DOWN,
  38         GRAPH_UP,
  39         GRAPH_CONN,
  40         GRAPH_KAD
  41 };
  42
  43 typedef struct UpdateInfo {
  44         double timestamp;
  45         float downloads[3];
  46         float uploads[3];
  47         float connections[3];
  48         float kadnodes[3];
  49 } GraphUpdateInfo;
  50
  51 typedef struct HistoryRecord {
  52         double          kBytesSent;
  53         double          kBytesReceived;
  54         float           kBpsUpCur;
  55         float           kBpsDownCur;
  56         double          sTimestamp;
  57         uint16          cntDownloads;
  58         uint16          cntUploads;
  59         uint16          cntConnections;
  60         uint16          kadNodesCur;
  61         uint64          kadNodesTotal;
  62 } HR;
  63
  64
  65 #ifndef EC_REMOTE
  66
  67 /**
  68  * Counts precise rate/average on added bytes/values.
  69  *
  70  * @note This class is MT-safe.
  71  */
  72 class CPreciseRateCounter {
  73         friend class CStatistics;       // for playing dirty tricks to compute running average :P
  74  public:
  75
  76         /**
  77          * Constructor
  78          *
  79          * @param timespan Desired timespan for rate calculations.
  80          * @param count_average Counts average instead of rate.
  81          */
  82         CPreciseRateCounter(uint32_t timespan, bool count_average = false)
  83                 : m_timespan(timespan), m_total(0), m_rate(0.0), m_max_rate(0.0), m_tmp_sum(0), m_count_average(count_average)
  84                 {
  85                         if (!count_average) {
  86                                 uint64_t cur_time = GetTickCount64();
  87                                 uint64_t target_time = cur_time - timespan;
  88                                 while (cur_time > target_time) {
  89                                         m_tick_history.push_front(cur_time);
  90                                         m_byte_history.push_front(0);
  91                                         cur_time -= 100;        // default update period
  92                                 }
  93                                 m_tick_history.push_front(cur_time);
  94                         }
  95                 }
  96
  97         /**
  98          * Calculate current rate.
  99          *
 100          * This function should be called reasonably often, to
 101          * keep rates up-to-date, and prevent history growing
 102          * to the skies.
 103          */
 104         void    CalculateRate(uint64_t now);
 105
 106         /**
 107          * Get current rate.
 108          *
 109          * @return Current rate in bytes/second.
 110          */
 111         double  GetRate()                       { wxMutexLocker lock(m_mutex); return m_rate; };
 112
 113         /**
 114          * Gets ever seen maximal rate.
 115          *
 116          * @return The maximal rate which occured.
 117          */
 118         double  GetMaxRate()                    { wxMutexLocker lock(m_mutex); return m_max_rate; }
 119
 120         /**
 121          * Sets desired timespan for rate calculations.
 122          *
 123          * If new timespan is greater than the old was, then the change
 124          * takes effect with time. The exact time needed for the change
 125          * to take effect is new minus old value of the timespan.
 126          *
 127          * If the new timespan is lower than the old, the change takes
 128          * effect immediately at the next call to CalculateRate().
 129          */
 130         void    SetTimespan(uint32_t timespan)  { wxMutexLocker lock(m_mutex); m_timespan = timespan; }
 131
 132         /**
 133          * Add bytes to be tracked for rate-counting.
 134          */
 135         void    operator+=(uint32_t bytes)      { wxMutexLocker lock(m_mutex); m_tmp_sum += bytes; }
 136
 137  protected:
 138
 139         std::deque<uint32>      m_byte_history;
 140         std::deque<uint64>      m_tick_history;
 141         uint32_t        m_timespan;
 142         uint32_t        m_total;
 143         double          m_rate;
 144         double          m_max_rate;
 145         uint32_t        m_tmp_sum;
 146         wxMutex         m_mutex;
 147         bool            m_count_average;
 148 };
 149
 150
 151 class CECTag;
 152
 153 /**
 154  * Stat tree item for rates/averages.
 155  */
 156 class CStatTreeItemRateCounter : public CStatTreeItemBase, public CPreciseRateCounter {
 157  public:
 158
 159         /**
 160          * @see CStatTreeItemBase::CStatTreeItemBase, CPreciseRateCounter::CPreciseRateCounter
 161          *
 162          * @param show_maxrate If true, shows max rate instead of current rate.
 163          */
 164         CStatTreeItemRateCounter(const wxString& label, bool show_maxrate, uint32_t timespan, bool count_average = false)
 165                 : CStatTreeItemBase(label, stNone), CPreciseRateCounter(timespan, count_average), m_show_maxrate(show_maxrate)
 166                 {}
 167
 168 #ifndef AMULE_DAEMON
 169         /**
 170          * @see CStatTreeItemBase::GetDisplayString()
 171          */
 172         virtual wxString GetDisplayString() const;
 173 #endif
 174
 175  protected:
 176         /**
 177          * Add values to EC tag being generated.
 178          *
 179          * @param tag The tag to which values should be added.
 180          *
 181          * @see CStatTreeItemBase::AddECValues
 182          */
 183         virtual void    AddECValues(CECTag* tag) const;
 184
 185         //! Whether to show max rate instead of actual rate.
 186         bool    m_show_maxrate;
 187 };
 188
 189
 190 /**
 191  * Stat tree item for Peak Connections.
 192  */
 193 class CStatTreeItemPeakConnections : public CStatTreeItemBase {
 194  public:
 195
 196         /**
 197          * @see CStatTreeItemBase::CStatTreeItemBase
 198          */
 199         CStatTreeItemPeakConnections(const wxString& label)
 200                 : CStatTreeItemBase(label)
 201                 {}
 202
 203 #ifndef AMULE_DAEMON
 204         /**
 205          * @see CStatTreeItemBase::GetDisplayString()
 206          */
 207         virtual wxString GetDisplayString() const;
 208 #endif
 209
 210  protected:
 211         /**
 212          * Add values to EC tag being generated.
 213          *
 214          * @param tag The tag to which values should be added.
 215          *
 216          * @see CStatTreeItemBase::AddECValues
 217          */
 218         virtual void    AddECValues(CECTag* tag) const;
 219 };
 220
 221
 222 class CUpDownClient;
 223
 224 class CStatistics {
 225         friend class CStatisticsDlg;    // to access CStatistics::GetTreeRoot()
 226  public:
 227         CStatistics();
 228         ~CStatistics();
 229
 230         /* Statistics graph functions */
 231
 232         void     RecordHistory();
 233         unsigned GetHistoryForWeb(unsigned cntPoints, double sStep, double *sStart, uint32 **graphData);
 234         unsigned GetHistory(unsigned cntPoints, double sStep, double sFinal, const std::vector<float *> &ppf, StatsGraphType which_graph);
 235         GraphUpdateInfo GetPointsForUpdate();
 236
 237         /* Statistics tree functions */
 238
 239         void UpdateStatsTree();
 240
 241         /* Access to the tree */
 242
 243         // uptime
 244         static  uint64  GetUptimeMillis()                       { return s_uptime->GetTimerValue(); }
 245         static  uint64  GetUptimeSeconds()                      { return s_uptime->GetTimerSeconds(); }
 246         static  uint64  GetStartTime()                          { return s_uptime->GetTimerStart(); }
 247
 248         // Upload
 249         static  uint64  GetSessionSentBytes()                   { return (*s_sessionUpload); }
 250         static  void    AddUpOverheadFileRequest(uint32 size)   { (*s_fileReqUpOverhead) += size; (*s_upOverheadRate) += size; }
 251         static  void    AddUpOverheadSourceExchange(uint32 size){ (*s_sourceXchgUpOverhead) += size; (*s_upOverheadRate) += size; }
 252         static  void    AddUpOverheadServer(uint32 size)        { (*s_serverUpOverhead) += size; (*s_upOverheadRate) += size; }
 253         static  void    AddUpOverheadKad(uint32 size)           { (*s_kadUpOverhead) += size; (*s_upOverheadRate) += size; }
 254         static  void    AddUpOverheadOther(uint32 size)         { (*s_totalUpOverhead) += size; (*s_upOverheadRate) += size; }
 255         static  double  GetUpOverheadRate()                     { return s_upOverheadRate->GetRate(); }
 256         static  void    AddSuccessfulUpload()                   { ++(*s_totalSuccUploads); }
 257         static  void    AddFailedUpload()                       { ++(*s_totalFailedUploads); }
 258         static  void    AddUploadTime(uint32 time)              { (*s_totalUploadTime) += time; }
 259         static  void    AddUploadingClient()                    { ++(*s_activeUploads); }
 260         static  void    RemoveUploadingClient()                 { --(*s_activeUploads); }
 261         static  uint32  GetActiveUploadsCount()                 { return (*s_activeUploads); }
 262         static  void    AddWaitingClient()                      { ++(*s_waitingUploads); }
 263         static  void    RemoveWaitingClient()                   { --(*s_waitingUploads); }
 264         static  uint32  GetWaitingUserCount()                   { return (*s_waitingUploads); }
 265         static  double  GetUploadRate()                         { return s_uploadrate->GetRate(); }
 266
 267         // Download
 268         static  uint64  GetSessionReceivedBytes()               { return (*s_sessionDownload); }
 269         static  void    AddDownOverheadFileRequest(uint32 size) { (*s_fileReqDownOverhead) += size; (*s_downOverheadRate) += size; }
 270         static  void    AddDownOverheadSourceExchange(uint32 size){ (*s_sourceXchgDownOverhead) += size; (*s_downOverheadRate) += size; }
 271         static  void    AddDownOverheadServer(uint32 size)      { (*s_serverDownOverhead) += size; (*s_downOverheadRate) += size; }
 272         static  void    AddDownOverheadKad(uint32 size)         { (*s_kadDownOverhead) += size; (*s_downOverheadRate) += size; }
 273         static  void    AddDownOverheadOther(uint32 size)       { (*s_totalDownOverhead) += size; (*s_downOverheadRate) += size; }
 274         static  double  GetDownOverheadRate()                   { return s_downOverheadRate->GetRate(); }
 275         static  void    AddFoundSource()                        { ++(*s_foundSources); }
 276         static  void    RemoveFoundSource()                     { --(*s_foundSources); }
 277         static  uint32  GetFoundSources()                       { return (*s_foundSources); }
 278         static  void    AddSourceOrigin(unsigned origin);
 279         static  void    RemoveSourceOrigin(unsigned origin);
 280         static  void    AddDownloadingSource()                  { ++(*s_activeDownloads); }
 281         static  void    RemoveDownloadingSource()               { --(*s_activeDownloads); }
 282         static  uint32  GetDownloadingSources()                 { return (*s_activeDownloads); }
 283         static  double  GetDownloadRate()                       { return s_downloadrate->GetRate(); }
 284
 285         // Connection
 286         static  CStatTreeItemTimer* GetServerConnectTimer()     { return s_sinceConnected; }
 287         static  void    AddReconnect()                          { ++(*s_reconnects); }
 288         static  void    AddActiveConnection()                   { ++(*s_activeConnections); }
 289         static  void    RemoveActiveConnection()                { --(*s_activeConnections); }
 290         static  uint32  GetActiveConnections()                  { return s_activeConnections->GetValue(); }
 291         static  uint32  GetPeakConnections()                    { return s_activeConnections->GetMaxValue(); }
 292         static  void    AddMaxConnectionLimitReached()          { ++(*s_limitReached); }
 293
 294         // Clients
 295         static  void    AddFilteredClient()                     { ++(*s_filtered); }
 296         static  void    AddUnknownClient()                      { ++(*s_unknown); }
 297         static  void    RemoveUnknownClient()                   { --(*s_unknown); }
 298         static  void    AddKnownClient(CUpDownClient *pClient);
 299         static  void    RemoveKnownClient(uint32 clientSoft, uint32 clientVersion, const wxString& OSInfo);
 300 #ifdef __DEBUG__
 301         static  void    SocketAssignedToClient()                { ++(*s_hasSocket); }
 302         static  void    SocketUnassignedFromClient()            { --(*s_hasSocket); }
 303 #endif
 304         static  uint32  GetBannedCount()                        { return (*s_banned); }
 305         static  void    AddBannedClient()                       { ++(*s_banned); }
 306         static  void    RemoveBannedClient()                    { --(*s_banned); }
 307
 308         // Servers
 309         static  void    AddServer()                             { ++(*s_totalServers); }
 310         static  void    DeleteServer()                          { ++(*s_deletedServers); --(*s_totalServers); }
 311         static  void    DeleteAllServers()                      { (*s_deletedServers) += (*s_totalServers); (*s_totalServers) = 0; }
 312         static  void    AddFilteredServer()                     { ++(*s_filteredServers); }
 313
 314         // Shared files
 315         static  void    ClearSharedFilesInfo()                  { (*s_numberOfShared) = 0; (*s_sizeOfShare) = 0; }
 316         static  void    AddSharedFile(uint64 size)              { ++(*s_numberOfShared); (*s_sizeOfShare) += size; }
 317         static  void    RemoveSharedFile(uint64 size)           { --(*s_numberOfShared); (*s_sizeOfShare) -= size; }
 318         static  uint32  GetSharedFileCount()                    { return (*s_numberOfShared); }
 319
 320         // Kad nodes
 321         static void             AddKadNode()                                    { ++s_kadNodesCur; }
 322         static void             RemoveKadNode()                                 { --s_kadNodesCur; }
 323
 324
 325         // Other
 326         static  void    CalculateRates();
 327
 328         static  void    AddReceivedBytes(uint32 bytes)
 329                 {
 330                         if (!s_sinceFirstTransfer->IsRunning()) {
 331                                 s_sinceFirstTransfer->StartTimer();
 332                         }
 333
 334                         (*s_sessionDownload) += bytes;
 335                         (*s_downloadrate) += bytes;
 336                 }
 337
 338         static  void    AddSentBytes(uint32 bytes)
 339                 {
 340                         if (!s_sinceFirstTransfer->IsRunning()) {
 341                                 s_sinceFirstTransfer->StartTimer();
 342                         }
 343
 344                         (*s_sessionUpload) += bytes;
 345                         (*s_uploadrate) += bytes;
 346                 }
 347
 348         static  void    AddDownloadFromSoft(uint8 SoftType, uint32 bytes);
 349         static  void    AddUploadToSoft(uint8 SoftType, uint32 bytes);
 350
 351         // EC
 352         static  CECTag* GetECStatTree(uint8 tree_capping_value) { return s_statTree->CreateECTag(tree_capping_value); }
 353
 354         void SetAverageMinutes(uint8 minutes) { average_minutes = minutes; }
 355
 356  private:
 357         std::list<HR>   listHR;
 358         typedef std::list<HR>::iterator         listPOS;
 359         typedef std::list<HR>::reverse_iterator listRPOS;
 360
 361         /* Graph-related functions */
 362
 363         void ComputeAverages(HR **pphr, listRPOS pos, unsigned cntFilled,
 364                 double sStep, const std::vector<float *> &ppf, StatsGraphType which_graph);
 365
 366         int GetPointsPerRange()
 367         {
 368                 return (1280/2) - 80; // This used to be a calc. based on GUI width
 369         }
 370
 371         /* Graphs-related vars */
 372
 373         CPreciseRateCounter     m_graphRunningAvgDown;
 374         CPreciseRateCounter     m_graphRunningAvgUp;
 375         CPreciseRateCounter     m_graphRunningAvgKad;
 376
 377
 378         uint8 average_minutes;
 379         int     nHistRanges;
 380         int     bitsHistClockMask;
 381         int     nPointsPerRange;
 382         listPOS*        aposRecycle;
 383
 384         HR hrInit;
 385
 386         /* Rate/Average counters */
 387         static  CPreciseRateCounter*            s_upOverheadRate;
 388         static  CPreciseRateCounter*            s_downOverheadRate;
 389         static  CStatTreeItemRateCounter*       s_uploadrate;
 390         static  CStatTreeItemRateCounter*       s_downloadrate;
 391
 392         /* Tree-related functions */
 393
 394         static  void    InitStatsTree();
 395
 396         static  CStatTreeItemBase*      GetTreeRoot()   { return s_statTree; }
 397
 398         /* Tree-related vars */
 399
 400         // the tree
 401         static  CStatTreeItemBase*              s_statTree;
 402
 403         // Uptime
 404         static  CStatTreeItemTimer*             s_uptime;
 405
 406         // Upload
 407         static  CStatTreeItemUlDlCounter*       s_sessionUpload;
 408         static  CStatTreeItemPacketTotals*      s_totalUpOverhead;
 409         static  CStatTreeItemPackets*           s_fileReqUpOverhead;
 410         static  CStatTreeItemPackets*           s_sourceXchgUpOverhead;
 411         static  CStatTreeItemPackets*           s_serverUpOverhead;
 412         static  CStatTreeItemPackets*           s_kadUpOverhead;
 413         static  CStatTreeItemNativeCounter*     s_activeUploads;
 414         static  CStatTreeItemNativeCounter*     s_waitingUploads;
 415         static  CStatTreeItemCounter*           s_totalSuccUploads;
 416         static  CStatTreeItemCounter*           s_totalFailedUploads;
 417         static  CStatTreeItemCounter*           s_totalUploadTime;
 418
 419         // Download
 420         static  CStatTreeItemUlDlCounter*       s_sessionDownload;
 421         static  CStatTreeItemPacketTotals*      s_totalDownOverhead;
 422         static  CStatTreeItemPackets*           s_fileReqDownOverhead;
 423         static  CStatTreeItemPackets*           s_sourceXchgDownOverhead;
 424         static  CStatTreeItemPackets*           s_serverDownOverhead;
 425         static  CStatTreeItemPackets*           s_kadDownOverhead;
 426         static  CStatTreeItemNativeCounter*     s_foundSources;
 427         static  CStatTreeItemNativeCounter*     s_activeDownloads;
 428
 429         // Connection
 430         static  CStatTreeItemReconnects*        s_reconnects;
 431         static  CStatTreeItemTimer*             s_sinceFirstTransfer;
 432         static  CStatTreeItemTimer*             s_sinceConnected;
 433         static  CStatTreeItemCounterMax*        s_activeConnections;
 434         static  CStatTreeItemMaxConnLimitReached* s_limitReached;
 435         static  CStatTreeItemSimple*            s_avgConnections;
 436
 437         // Clients
 438         static  CStatTreeItemHiddenCounter*     s_clients;
 439         static  CStatTreeItemCounter*           s_unknown;
 440         //static        CStatTreeItem                   s_lowID;
 441         //static        CStatTreeItem                   s_secIdentOnOff;
 442 #ifdef __DEBUG__
 443         static  CStatTreeItemNativeCounter*     s_hasSocket;
 444 #endif
 445         static  CStatTreeItemNativeCounter*     s_filtered;
 446         static  CStatTreeItemNativeCounter*     s_banned;
 447
 448         // Servers
 449         static  CStatTreeItemSimple*            s_workingServers;
 450         static  CStatTreeItemSimple*            s_failedServers;
 451         static  CStatTreeItemNativeCounter*     s_totalServers;
 452         static  CStatTreeItemNativeCounter*     s_deletedServers;
 453         static  CStatTreeItemNativeCounter*     s_filteredServers;
 454         static  CStatTreeItemSimple*            s_usersOnWorking;
 455         static  CStatTreeItemSimple*            s_filesOnWorking;
 456         static  CStatTreeItemSimple*            s_totalUsers;
 457         static  CStatTreeItemSimple*            s_totalFiles;
 458         static  CStatTreeItemSimple*            s_serverOccupation;
 459
 460         // Shared files
 461         static  CStatTreeItemCounter*           s_numberOfShared;
 462         static  CStatTreeItemCounter*           s_sizeOfShare;
 463
 464         // Kad nodes
 465         static uint64 s_kadNodesTotal;
 466         static uint16 s_kadNodesCur;
 467 };
 468
 469 #else /* EC_REMOTE == CLIENT_GUI */
 470
 471 class CECPacket;
 472 class CRemoteConnect;
 473
 474 enum StatDataIndex {
 475         sdUpload,
 476         sdUpOverhead,
 477         sdDownload,
 478         sdDownOverhead,
 479         sdWaitingClients,
 480         sdBannedClients,
 481         sdED2KUsers,
 482         sdKadUsers,
 483         sdED2KFiles,
 484         sdKadFiles,
 485
 486         sdTotalItems
 487 };
 488
 489 class CStatistics {
 490         friend class CStatisticsDlg;    // to access CStatistics::GetTreeRoot()
 491
 492 private:
 493         CRemoteConnect &m_conn;
 494         static CStatTreeItemBase* s_statTree;
 495         static uint64 s_start_time;
 496         static uint64 s_statData[sdTotalItems];
 497         uint8 average_minutes;
 498
 499  public:
 500         CStatistics(CRemoteConnect &conn);
 501         ~CStatistics();
 502
 503         static  uint64  GetUptimeMillis()                       { return GetTickCount64() - s_start_time; }
 504         static  uint64  GetUptimeSeconds()                      { return (GetTickCount64() - s_start_time) / 1000; }
 505
 506         static  uint64  GetSessionSentBytes()                   { return 0; } // TODO
 507         static  double  GetUploadRate()                         { return (double)s_statData[sdUpload]; }
 508         static  double  GetUpOverheadRate()                     { return (double)s_statData[sdUpOverhead]; }
 509
 510         static  uint64  GetSessionReceivedBytes()               { return 0; } // TODO
 511         static  double  GetDownloadRate()                       { return (double)s_statData[sdDownload]; }
 512         static  double  GetDownOverheadRate()                   { return (double)s_statData[sdDownOverhead]; }
 513
 514         static  uint32  GetWaitingUserCount()                   { return s_statData[sdWaitingClients]; }
 515         static  uint32  GetBannedCount()                        { return s_statData[sdBannedClients]; }
 516
 517         static  uint32  GetSharedFileCount()                    { return 0; } // TODO
 518
 519         static  uint32  GetED2KUsers()                  { return s_statData[sdED2KUsers]; }
 520         static  uint32  GetKadUsers()                   { return s_statData[sdKadUsers]; }
 521         static  uint32  GetED2KFiles()                  { return s_statData[sdED2KFiles]; }
 522         static  uint32  GetKadFiles()                   { return s_statData[sdKadFiles]; }
 523
 524         static  void    UpdateStats(const CECPacket* stats);
 525
 526                 void    UpdateStatsTree();
 527                 void    SetAverageMinutes(uint8 minutes)        { average_minutes = minutes; }
 528
 529  private:
 530         static  CStatTreeItemBase*      GetTreeRoot()           { return s_statTree; }
 531 };
 532
 533 #endif /* !EC_REMOTE / EC_REMOTE */
 534
 535
 536 /**
 537  * Shortcut for CStatistics
 538  */
 539 typedef CStatistics     theStats;
 540
 541 #endif // STATISTICS_H
 542 // File_checked_for_headers