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 char* UserDir();
  59         static char* ServerDir ( const char* server_name, char* server_dir );
  60         static const char* DefaultServerName();
  61         static void CleanupFiles ( const char* server_name );
  62         static int GetTmpdir();
  63         static void RewriteName ( const char* name, char* new_name );
  64     };
  65
  66     /*!
  67     \brief Generic monitoring class. Saves data to GnuPlot files ('.plt' and '.log' datafile)
  68
  69     This template class allows to manipulate monitoring records, and automatically generate the GnuPlot config and data files.
  70     Operations are RT safe because it uses fixed size data buffers.
  71     You can set the number of measure points, and the number of records.
  72
  73     To use it :
  74     - create a JackGnuPlotMonitor, you can use the data type you want.
  75     - create a temporary array for your measure
  76     - once you have filled this array with 'measure points' value, call write() to add it to the record
  77     - once you've done with your measurment, just call save() to save your data file
  78
  79     You can also call SetPlotFile() to automatically generate '.plt' file from an options list.
  80
  81     */
  82
  83     template <class T> class JackGnuPlotMonitor
  84     {
  85         private:
  86             uint32_t fMeasureCnt;
  87             uint32_t fMeasurePoints;
  88             uint32_t fMeasureId;
  89             T* fCurrentMeasure;
  90             T** fMeasureTable;
  91             uint32_t fTablePos;
  92             std::string fName;
  93
  94         public:
  95             JackGnuPlotMonitor ( uint32_t measure_cnt = 512, uint32_t measure_points = 5, std::string name = std::string ( "default" ) )
  96             {
  97                 jack_log ( "JackGnuPlotMonitor::JackGnuPlotMonitor %u measure points - %u measures", measure_points, measure_cnt );
  98
  99                 fMeasureCnt = measure_cnt;
 100                 fMeasurePoints = measure_points;
 101                 fTablePos = 0;
 102                 fName = name;
 103                 fCurrentMeasure = new T[fMeasurePoints];
 104                 fMeasureTable = new T*[fMeasureCnt];
 105                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 106                 {
 107                     fMeasureTable[cnt] = new T[fMeasurePoints];
 108                     fill_n ( fMeasureTable[cnt], fMeasurePoints, 0 );
 109                 }
 110             }
 111
 112             ~JackGnuPlotMonitor()
 113             {
 114                 jack_log ( "JackGnuPlotMonitor::~JackGnuPlotMonitor" );
 115
 116                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 117                     delete[] fMeasureTable[cnt];
 118                 delete[] fMeasureTable;
 119                 delete[] fCurrentMeasure;
 120             }
 121
 122             T AddNew ( T measure_point )
 123             {
 124                                 fMeasureId = 0;
 125                                 return fCurrentMeasure[fMeasureId++] = measure_point;
 126             }
 127
 128                         uint32_t New()
 129                         {
 130                                 return fMeasureId = 0;
 131                         }
 132
 133             T Add ( T measure_point )
 134             {
 135                                 return fCurrentMeasure[fMeasureId++] = measure_point;
 136             }
 137
 138             uint32_t AddLast ( T measure_point )
 139             {
 140                 fCurrentMeasure[fMeasureId] = measure_point;
 141                 fMeasureId = 0;
 142                 return Write();
 143             }
 144
 145             uint32_t Write()
 146             {
 147                 for ( uint32_t point = 0; point < fMeasurePoints; point++ )
 148                     fMeasureTable[fTablePos][point] = fCurrentMeasure[point];
 149                 if ( ++fTablePos == fMeasureCnt )
 150                     fTablePos = 0;
 151                 return fTablePos;
 152             }
 153
 154             int Save ( std::string name = std::string ( "" ) )
 155             {
 156                 std::string filename = ( name.empty() ) ? fName : name;
 157                 filename += ".log";
 158
 159                 jack_log ( "JackGnuPlotMonitor::Save filename %s", filename.c_str() );
 160
 161                 std::ofstream file ( filename.c_str() );
 162
 163                 for ( uint32_t cnt = 0; cnt < fMeasureCnt; cnt++ )
 164                 {
 165                     for ( uint32_t point = 0; point < fMeasurePoints; point++ )
 166                         file << fMeasureTable[cnt][point] << " \t";
 167                     file << std::endl;
 168                 }
 169
 170                 file.close();
 171                 return 0;
 172             }
 173
 174             int SetPlotFile ( std::string* options_list = NULL, uint32_t options_number = 0,
 175                               std::string* field_names = NULL, uint32_t field_number = 0,
 176                               std::string name = std::string ( "" ) )
 177             {
 178                 std::string title = ( name.empty() ) ? fName : name;
 179                 std::string plot_filename = title + ".plt";
 180                 std::string data_filename = title + ".log";
 181
 182                 std::ofstream file ( plot_filename.c_str() );
 183
 184                 file << "set multiplot" << std::endl;
 185                 file << "set grid" << std::endl;
 186                 file << "set title \"" << title << "\"" << std::endl;
 187
 188                 for ( uint32_t i = 0; i < options_number; i++ )
 189                     file << options_list[i] << std::endl;
 190
 191                 file << "plot ";
 192                 for ( uint32_t row = 1; row <= field_number; row++ )
 193                 {
 194                     file << "\"" << data_filename << "\" using " << row << " title \"" << field_names[row-1] << "\" with lines";
 195                     file << ( ( row < field_number ) ? ", " : "\n" );
 196                 }
 197
 198                 jack_log ( "JackGnuPlotMonitor::SetPlotFile - Save GnuPlot file to '%s'", plot_filename.c_str() );
 199
 200                 file.close();
 201                 return 0;
 202             }
 203     };
 204
 205     void BuildClientPath(char* path_to_so, int path_len, const char* so_name);
 206     void PrintLoadError(const char* so_name);
 207
 208 }
 209
 210 #endif