common/JackTools.h

   1 /*
   2   Copyright (C) 2006-2008 Grame
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU Lesser General Public License as published by
   6   the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #ifndef __JackTools__
  21 #define __JackTools__
  22
  23 #ifdef WIN32
  24 #include <windows.h>
  25 #else
  26 #include <sys/types.h>
  27 #include <unistd.h>
  28 #include <dirent.h>
  29 #endif
  30
  31 #ifdef __APPLE__
  32 #include <sys/syslimits.h>
  33 #endif
  34
  35 #include "jslist.h"
  36 #include "driver_interface.h"
  37 #include "JackCompilerDeps.h"
  38 #include "JackError.h"
  39
  40 #include <string>
  41 #include <algorithm>
  42 #include <vector>
  43 #include <iostream>
  44 #include <fstream>
  45
  46 namespace Jack
  47 {
  48
  49     /*!
  50     \brief Utility functions.
  51     */
  52
  53     struct SERVER_EXPORT JackTools
  54     {
  55         static int GetPID();
  56         static int GetUID();
  57
  58         static void KillServer();
  59
  60         static char* UserDir();
  61         static char* ServerDir ( const char* server_name, char* server_dir );
  62         static const char* DefaultServerName();
  63         static void CleanupFiles ( const char* server_name );
  64         static int GetTmpdir();
  65         static void RewriteName ( const char* name, char* new_name );
  66     };
  67
  68     /*!
  69     \brief Generic monitoring class. Saves data to GnuPlot files ('.plt' and '.log' datafile)
  70
  71     This template class allows to manipulate monitoring records, and automatically generate the GnuPlot config and data files.
  72     Operations are RT safe because it uses fixed size data buffers.
  73     You can set the number of measure points, and the number of records.
  74
  75     To use it :
  76     - create a JackGnuPlotMonitor, you can use the data type you want.
  77     - create a temporary array for your measure
  78     - once you have filled this array with 'measure points' value, call write() to add it to the record
  79     - once you've done with your measurment, just call save() to save your data file
  80
  81     You can also call SetPlotFile() to automatically generate '.plt' file from an options list.
  82
  83     */
  84
  85     template <class T> class JackGnuPlotMonitor
  86     {
  87         private:
  88             uint32_t fMeasureCnt;
  89             uint32_t fMeasurePoints;
  90             uint32_t fMeasureId;
  91             T* fCurrentMeasure;
  92             T** fMeasureTable;
  93             uint32_t fTablePos;
  94             std::string fName;
  95
  96         public:
  97             JackGnuPlotMonitor ( uint32_t measure_cnt = 512, uint32_t measure_points = 5, std::string name = std::string ( "default" ) )
  98             {
  99                 jack_log ( "JackGnuPlotMonitor::JackGnuPlotMonitor %u measure points - %u measures", measure_points, measure_cnt );
 100
 101                 fMeasureCnt = measure_cnt;
 102                 fMeasurePoints = measure_points;
 103                 fTablePos = 0;
 104                 fName = name;
 105                 fCurrentMeasure = new T[fMeasurePoints];
 106                 fMeasureTable = new T*[fMeasureCnt];
 107                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 108                 {
 109                     fMeasureTable[cnt] = new T[fMeasurePoints];
 110                     fill_n ( fMeasureTable[cnt], fMeasurePoints, 0 );
 111                 }
 112             }
 113
 114             ~JackGnuPlotMonitor()
 115             {
 116                 jack_log ( "JackGnuPlotMonitor::~JackGnuPlotMonitor" );
 117
 118                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 119                     delete[] fMeasureTable[cnt];
 120                 delete[] fMeasureTable;
 121                 delete[] fCurrentMeasure;
 122             }
 123
 124             T AddNew ( T measure_point )
 125             {
 126                                 fMeasureId = 0;
 127                                 return fCurrentMeasure[fMeasureId++] = measure_point;
 128             }
 129
 130                         uint32_t New()
 131                         {
 132                                 return fMeasureId = 0;
 133                         }
 134
 135             T Add ( T measure_point )
 136             {
 137                                 return fCurrentMeasure[fMeasureId++] = measure_point;
 138             }
 139
 140             uint32_t AddLast ( T measure_point )
 141             {
 142                 fCurrentMeasure[fMeasureId] = measure_point;
 143                 fMeasureId = 0;
 144                 return Write();
 145             }
 146
 147             uint32_t Write()
 148             {
 149                 for ( uint32_t point = 0; point < fMeasurePoints; point++ )
 150                     fMeasureTable[fTablePos][point] = fCurrentMeasure[point];
 151                 if ( ++fTablePos == fMeasureCnt )
 152                     fTablePos = 0;
 153                 return fTablePos;
 154             }
 155
 156             int Save ( std::string name = std::string ( "" ) )
 157             {
 158                 std::string filename = ( name.empty() ) ? fName : name;
 159                 filename += ".log";
 160
 161                 jack_log ( "JackGnuPlotMonitor::Save filename %s", filename.c_str() );
 162
 163                 std::ofstream file ( filename.c_str() );
 164
 165                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 166                 {
 167                     for ( uint32_t point = 0; point < fMeasurePoints; point++ )
 168                         file << fMeasureTable[cnt][point] << " \t";
 169                     file << std::endl;
 170                 }
 171
 172                 file.close();
 173                 return 0;
 174             }
 175
 176             int SetPlotFile ( std::string* options_list = NULL, uint32_t options_number = 0,
 177                               std::string* field_names = NULL, uint32_t field_number = 0,
 178                               std::string name = std::string ( "" ) )
 179             {
 180                 std::string title = ( name.empty() ) ? fName : name;
 181                 std::string plot_filename = title + ".plt";
 182                 std::string data_filename = title + ".log";
 183
 184                 std::ofstream file ( plot_filename.c_str() );
 185
 186                 file << "set multiplot" << std::endl;
 187                 file << "set grid" << std::endl;
 188                 file << "set title \"" << title << "\"" << std::endl;
 189
 190                 for ( uint32_t i = 0; i < options_number; i++ )
 191                     file << options_list[i] << std::endl;
 192
 193                 file << "plot ";
 194                 for ( uint32_t row = 1; row <= field_number; row++ )
 195                 {
 196                     file << "\"" << data_filename << "\" using " << row << " title \"" << field_names[row-1] << "\" with lines";
 197                     file << ( ( row < field_number ) ? ", " : "\n" );
 198                 }
 199
 200                 jack_log ( "JackGnuPlotMonitor::SetPlotFile - Save GnuPlot file to '%s'", plot_filename.c_str() );
 201
 202                 file.close();
 203                 return 0;
 204             }
 205     };
 206
 207     void BuildClientPath(char* path_to_so, int path_len, const char* so_name);
 208     void PrintLoadError(const char* so_name);
 209
 210 }
 211
 212 #endif