common/JackEngineTiming.cpp

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackEngineTiming.h"
  21 #include "JackClientInterface.h"
  22 #include "JackEngineControl.h"
  23 #include "JackClientControl.h"
  24 #include <math.h>
  25 #include <algorithm>
  26 #include <iostream>
  27 #include <assert.h>
  28
  29 namespace Jack
  30 {
  31
  32 inline jack_time_t MAX(jack_time_t a, jack_time_t b)
  33 {
  34     return (a < b) ? b : a;
  35 }
  36
  37 JackEngineTiming::JackEngineTiming(JackClientInterface** table, JackGraphManager* manager, JackEngineControl* control)
  38 {
  39     fClientTable = table;
  40     fGraphManager = manager;
  41     fEngineControl = control;
  42     fLastTime = 0;
  43     fCurTime = 0;
  44     fProcessTime = 0;
  45     fLastProcessTime = 0;
  46     fSpareUsecs = 0;
  47     fMaxUsecs = 0;
  48     fAudioCycle = 0;
  49 }
  50
  51 void JackEngineTiming::UpdateTiming(jack_time_t callback_usecs)
  52 {
  53     GetTimeMeasure(callback_usecs);
  54     CalcCPULoad();
  55 }
  56
  57 void JackEngineTiming::CalcCPULoad()
  58 {
  59     jack_time_t lastCycleEnd = fLastProcessTime;
  60
  61     for (int i = REAL_REFNUM; i < CLIENT_NUM; i++) {
  62         JackClientInterface* client = fClientTable[i];
  63                 JackClientTiming* timing = fGraphManager->GetClientTiming(i);
  64                 if (client && client->GetClientControl()->fActive && timing->fStatus == Finished) {
  65             lastCycleEnd = MAX(lastCycleEnd, timing->fFinishedAt);
  66         }
  67     }
  68
  69     /* store the execution time for later averaging */
  70     fRollingClientUsecs[fRollingClientUsecsIndex++] = lastCycleEnd - fLastTime;
  71
  72     if (fRollingClientUsecsIndex >= JACK_ENGINE_ROLLING_COUNT) {
  73         fRollingClientUsecsIndex = 0;
  74     }
  75
  76     /* every so often, recompute the current maximum use over the
  77        last JACK_ENGINE_ROLLING_COUNT client iterations.
  78     */
  79
  80     if (++fRollingClientUsecsCnt % fRollingInterval == 0) {
  81
  82         jack_time_t maxUsecs = 0;
  83         for (int i = 0; i < JACK_ENGINE_ROLLING_COUNT; i++) {
  84             maxUsecs = MAX(fRollingClientUsecs[i], maxUsecs);
  85         }
  86
  87         fMaxUsecs = MAX(fMaxUsecs, maxUsecs);
  88         fSpareUsecs = jack_time_t((maxUsecs < fEngineControl->fPeriodUsecs) ? fEngineControl->fPeriodUsecs - maxUsecs : 0);
  89         fEngineControl->fCPULoad
  90         = ((1.0f - (float(fSpareUsecs) / float(fEngineControl->fPeriodUsecs))) * 50.0f + (fEngineControl->fCPULoad * 0.5f));
  91     }
  92 }
  93
  94 void JackEngineTiming::ResetRollingUsecs()
  95 {
  96     memset(fRollingClientUsecs, 0, sizeof(fRollingClientUsecs));
  97     fRollingClientUsecsIndex = 0;
  98     fRollingClientUsecsCnt = 0;
  99     fSpareUsecs = 0;
 100     fRollingInterval = (int)floor((JACK_ENGINE_ROLLING_INTERVAL * 1000.0f) / fEngineControl->fPeriodUsecs);
 101 }
 102
 103 void JackEngineTiming::GetTimeMeasure(jack_time_t callbackUsecs)
 104 {
 105     int pos = (++fAudioCycle) % TIME_POINTS;
 106
 107     fLastTime = fCurTime;
 108     fCurTime = callbackUsecs;
 109
 110     fLastProcessTime = fProcessTime;
 111     fProcessTime = GetMicroSeconds();
 112
 113     if (fLastTime > 0) {
 114         fMeasure[pos].fEngineTime = fLastTime;
 115         fMeasure[pos].fAudioCycle = fAudioCycle;
 116
 117         for (int i = 0; i < CLIENT_NUM; i++) {
 118             JackClientInterface* client = fClientTable[i];
 119                         JackClientTiming* timing = fGraphManager->GetClientTiming(i);
 120             if (client && client->GetClientControl()->fActive) {
 121                             fMeasure[pos].fClientTable[i].fRefNum = i;
 122                 fMeasure[pos].fClientTable[i].fSignaledAt = timing->fSignaledAt;
 123                 fMeasure[pos].fClientTable[i].fAwakeAt = timing->fAwakeAt;
 124                 fMeasure[pos].fClientTable[i].fFinishedAt = timing->fFinishedAt;
 125                 fMeasure[pos].fClientTable[i].fStatus = timing->fStatus;
 126             }
 127         }
 128     }
 129 }
 130
 131 void JackEngineTiming::PrintState()
 132 {
 133     jack_time_t prevtime, time;
 134     prevtime = time = fMeasure[0].fEngineTime;
 135     int cycle, prevcycle = fMeasure[0].fAudioCycle;
 136     /*
 137
 138        std::ofstream f("measure.txt");
 139
 140        if (f.is_open()) {
 141
 142            //std::cout << "---------------------------------------------" << std::endl;
 143
 144            for (int i = 0; i < CLIENT_NUM; i++) { // client
 145                JackClientInterface* client = fClientTable[i];
 146                 if (client && client->GetClientControl()->fActive) {
 147                    // f << "Client : " << i << std::endl;
 148                    long maxsignalledat = 0;
 149                    long maxawakedat = 0;
 150                    long maxfinisheddat = 0;
 151                    bool max = false;
 152                    prevtime = fMeasure[0].fEngineTime;
 153                    prevcycle = fMeasure[0].fAudioCycle;
 154
 155                         // TODO
 156
 157                    for (int j = 0; j < TIME_POINTS; j++) { // measure
 158                        time = fMeasure[j].fEngineTime;
 159                        cycle = fMeasure[j].fAudioCycle;
 160
 161                        if (fMeasure[j].fClientTable[i].fRefNum > 0) {
 162
 163                            if (fMeasure[j].fClientTable[i].fStatus != Finished) {
 164                                f << "error status " << '\t'
 165                                << prevtime << '\t'
 166                                << time << '\t'
 167                                << fMeasure[j + 1].fEngineTime << '\t'
 168                                << prevcycle << '\t'
 169                                << cycle << '\t'
 170                                << fMeasure[j].fClientTable[i].fSignaledAt << '\t'
 171                                << fMeasure[j].fClientTable[i].fAwakeAt << '\t'
 172                                << fMeasure[j].fClientTable[i].fFinishedAt
 173                                << std::endl;
 174                            }
 175
 176                            if (long(time - prevtime) > 0) {
 177
 178                                f << long(time - prevtime) << '\t'
 179                                << fMeasure[j].fClientTable[i].fSignaledAt - time << '\t'
 180                                << fMeasure[j].fClientTable[i].fAwakeAt - time << '\t'
 181                                << fMeasure[j].fClientTable[i].fFinishedAt - time << '\t'
 182                                << fMeasure[j].fClientTable[i].fStatus
 183                                << std::endl;
 184                            } else {
 185                                f << "error time : " << j << " " << long(time - prevtime) << std::endl;
 186                            }
 187
 188                            maxsignalledat = MAX(maxsignalledat, long(fMeasure[j].fClientTable[i].fSignaledAt - time));
 189                            maxawakedat = MAX(maxawakedat, long(fMeasure[j].fClientTable[i].fAwakeAt - time));
 190                            maxfinisheddat = MAX(maxfinisheddat, long(fMeasure[j].fClientTable[i].fFinishedAt - time));
 191                            max = true;
 192                        }
 193                        prevtime = time;
 194                        prevcycle = cycle;
 195                    }
 196
 197
 198                    f << std::endl;
 199                    if (max) {
 200                        f << "maxsignalledat: " << maxsignalledat
 201                        << '\t' << "maxawakedat: " << maxawakedat
 202                        << '\t' << "maxfinisheddat: " << maxfinisheddat
 203                        << '\t' << std::endl;
 204                    }
 205                }
 206            }
 207
 208            f.close();
 209        }
 210     */
 211 }
 212
 213 void JackEngineTiming::ClearTimeMeasures()
 214 {
 215     for (int i = 0; i < TIME_POINTS; i++) {
 216         for (int j = 0; j < CLIENT_NUM; j++) {
 217             fMeasure[i].fClientTable[j].fRefNum = 0;
 218             fMeasure[i].fClientTable[j].fSignaledAt = 0;
 219             fMeasure[i].fClientTable[j].fAwakeAt = 0;
 220             fMeasure[i].fClientTable[j].fFinishedAt = 0;
 221         }
 222     }
 223     fLastTime = fCurTime = 0;
 224 }
 225
 226
 227 } // end of namespace
 228