subsystems/pktsize/PktSizeMon.cc

0001 #include "PktSizeMon.h"
0002 #include "PktSizeCommon.h"
0003 #include "PktSizeDBodbc.h"
0004
0005 #include <onlmon/OnlMonServer.h>
0006
0007 #include <Event/Event.h>
0008 #include <Event/EventTypes.h>
0009 #include <Event/msg_profile.h>
0010
0011 #include <phool/phool.h>
0012
0013 #include <TH1.h>
0014
0015 #include <iostream>
0016 #include <sstream>
0017 #include <vector>
0018
0019 const char *histoname = "pktsize_hist";
0020 const int NUPDATE = 1000;
0021
0022 PktSizeMon::PktSizeMon(const std::string &name)
0023   : OnlMon(name)
0024   , nevnts(0)
0025   , db(new PktSizeDBodbc(name))
0026 {
0027   return;
0028 }
0029
0030 PktSizeMon::~PktSizeMon()
0031 {
0032   Reset();
0033   delete db;
0034   return;
0035 }
0036
0037 // void
0038 // PktSizeMon::Verbosity(const int i)
0039 // {
0040 //  if (db)
0041 //     {
0042 //        db->Verbosity(i);
0043 //     }
0044 //   OnlMon::Verbosity(i);
0045 //   return ;
0046 // }
0047
0048 int PktSizeMon::Init()
0049 {
0050   OnlMonServer *se = OnlMonServer::instance();
0051   sizehist = new TH1F(histoname, "dummy", 1, 0, 1);
0052   se->registerHisto(this, sizehist);
0053   PktSizeCommon::fillgranules(granulepacketlimits);
0054   PktSizeCommon::filldcmgroups(dcmgroups);
0055   PktSizeCommon::fillfibergroups(fibergroups);
0056   return 0;
0057 }
0058
0059 int PktSizeMon::Reset()
0060 {
0061   packetsize.clear();
0062
0063   OnlMonServer *se = OnlMonServer::instance();
0064   TH1 *newhist = new TH1F("pktsize_tmp", "packet size storage facility", 1, 0, 1);
0065   se->registerHisto(this->Name(), histoname, newhist, 1);
0066   sizehist = newhist;
0067   nevnts = 0;
0068   return 0;
0069 }
0070
0071 int PktSizeMon::process_event(Event *e)
0072 {
0073   // only data events
0074   if (e->getEvtType() != DATAEVENT)
0075   {
0076     return 0;
0077   }
0078   std::vector<Packet*> pktvec = e->getPacketVector();
0079   int packetid;
0080   unsigned int size;
0081   std::map<unsigned int, unsigned int>::iterator mapiter;
0082   for (Packet* pkt : pktvec)
0083   {
0084     packetid = pkt->getIdentifier();
0085     size = (pkt->getLength());
0086     packetsize[packetid] += size;
0087     //      std::string dcmgrp = dcmgroups[packetid];
0088     //      dcmgroupsize[dcmgrp] += size;
0089     //       mapiter = packetsize.find(packetid);
0090     //       if (mapiter != packetsize.end())
0091     //         {
0092     //           mapiter->second += size;
0093     //         }
0094     //       else
0095     //         {
0096     //           packetsize[packetid] = size;
0097     //         }
0098     if (verbosity > 1)
0099     {
0100     std::cout << "Packet " << packetid << " size: " << size << " sum size: "
0101           << packetsize[packetid] << std::endl;
0102     }
0103     delete pkt;
0104   }
0105   nevnts++;
0106   if (nevnts % NUPDATE == 0)
0107   {
0108     if (verbosity > 0)
0109     {
0110       std::cout << "putting map into histos" << std::endl;
0111     }
0112     putmapinhisto();
0113   }
0114   return 0;
0115 }
0116
0117 int PktSizeMon::EndRun(const int runno)
0118 {
0119   putmapinhisto();
0120   UpdateDB(runno);
0121   return 0;
0122 }
0123
0124 int PktSizeMon::putmapinhisto()
0125 {
0126   OnlMonServer *se = OnlMonServer::instance();
0127   if (packetsize.size() != (unsigned int) sizehist->GetNbinsX())
0128   {
0129     TH1 *newhist = new TH1F("pktsize_tmp", "packet size storage facility", packetsize.size(), 0, packetsize.size());
0130     se->registerHisto(this->Name(), histoname, newhist, 1);
0131     newhist->SetName(histoname);
0132     sizehist = newhist;
0133   }
0134   std::map<unsigned int, unsigned int>::const_iterator mapiter;
0135   int nbin = 1;
0136   double aversize;
0137   sizehist->SetBinContent(0, nevnts);  // fill number of evts into 0th bin
0138   for (mapiter = packetsize.begin(); mapiter != packetsize.end(); ++mapiter)
0139   {
0140     aversize = (double) (mapiter->second) / (double) (nevnts);
0141     sizehist->SetBinContent(nbin, aversize);
0142     sizehist->SetBinError(nbin, mapiter->first);
0143     nbin++;
0144   }
0145   return 0;
0146 }
0147
0148 void PktSizeMon::Print(const std::string &what)
0149 {
0150   if (what == "ALL")
0151   {
0152     std::map<unsigned int, unsigned int>::const_iterator mapiter;
0153     for (mapiter = packetsize.begin(); mapiter != packetsize.end(); ++mapiter)
0154     {
0155       std::cout << "Packet " << mapiter->first
0156            << ", SumBytes " << mapiter->second
0157            << ", Average " << (float) (mapiter->second) / (float) (nevnts)
0158            << std::endl;
0159       if (dcmgroups.find(mapiter->first) == dcmgroups.end())
0160       {
0161         std::cout << "could not find dcm group for packet " << mapiter->first << std::endl;
0162       }
0163       else
0164       {
0165         std::string dcmgrp = dcmgroups[mapiter->first];
0166         dcmgroupsize[dcmgrp] += mapiter->second;
0167         std::string fibergrp = fibergroups[mapiter->first];
0168         fibergroupsize[fibergrp] += mapiter->second;
0169       }
0170     }
0171
0172     std::map<std::string, unsigned int>::const_iterator iter;
0173     for (iter = dcmgroupsize.begin(); iter != dcmgroupsize.end(); ++iter)
0174     {
0175       std::cout << "DCM group " << iter->first
0176            << ", SumBytes " << iter->second
0177            << ", Average " << (float) (iter->second) / (float) (nevnts)
0178            << std::endl;
0179     }
0180
0181     for (iter = fibergroupsize.begin(); iter != fibergroupsize.end(); ++iter)
0182     {
0183       std::cout << "Fiber group " << iter->first
0184            << ", SumBytes " << iter->second
0185            << ", Average " << (float) (iter->second) / (float) (nevnts)
0186            << std::endl;
0187     }
0188   }
0189   if (what == "GRANULES")
0190   {
0191     std::map<std::string, std::pair<unsigned int, unsigned int> >::const_iterator mapiter;
0192     for (mapiter = granulepacketlimits.begin(); mapiter != granulepacketlimits.end(); ++mapiter)
0193     {
0194       std::cout << "Granule " << mapiter->first
0195            << ", Min Packet " << mapiter->second.first
0196            << ", Max Packet " << mapiter->second.second
0197            << std::endl;
0198     }
0199   }
0200   if (what == "SORT")
0201   {
0202     std::multimap<double, int> sortlist;
0203     std::map<unsigned int, unsigned int>::const_iterator mapiter;
0204     for (mapiter = packetsize.begin(); mapiter != packetsize.end(); ++mapiter)
0205     {
0206       double aversize = (double) (mapiter->second) / (double) (nevnts);
0207       sortlist.insert(std::pair<double, int>(aversize, mapiter->first));
0208     }
0209     std::multimap<double, int>::const_iterator mmapiter;
0210     for (mmapiter = sortlist.begin(); mmapiter != sortlist.end(); ++mmapiter)
0211     {
0212       std::cout << "Packet " << mmapiter->second
0213            << " Size: " << mmapiter->first
0214            << " Bytes "
0215            << std::endl;
0216     }
0217   }
0218   if (what == "DCMGROUP")
0219   {
0220     std::map<std::string, std::set<unsigned int> > dcms;
0221     std::map<unsigned int, std::string>::const_iterator iter;
0222     for (iter = dcmgroups.begin(); iter != dcmgroups.end(); ++iter)
0223     {
0224       std::map<std::string, std::set<unsigned int> >::iterator iter2 = dcms.find(iter->second);
0225       if (iter2 == dcms.end())
0226       {
0227         std::set<unsigned int> newset;
0228         newset.insert(iter->first);
0229         dcms[iter->second] = newset;
0230       }
0231       else
0232       {
0233         (iter2->second).insert(iter->first);
0234       }
0235     }
0236     std::map<std::string, std::set<unsigned int> >::const_iterator iter3;
0237     std::set<unsigned int>::const_iterator iter4;
0238     for (iter3 = dcms.begin(); iter3 != dcms.end(); ++iter3)
0239     {
0240       std::cout << "dcm group " << iter3->first << " packets: " << std::endl;
0241       for (iter4 = (iter3->second).begin(); iter4 != (iter3->second).end(); ++iter4)
0242       {
0243         std::cout << *iter4 << " ";
0244       }
0245       std::cout << std::endl;
0246     }
0247   }
0248   return;
0249 }
0250
0251 int PktSizeMon::UpdateDB(const int runno)
0252 {
0253   std::map<std::string, std::pair<unsigned int, unsigned int> >::const_iterator graniter;
0254   std::string name;
0255   unsigned int lolim, hilim;
0256   std::map<unsigned int, unsigned int> granpackets;
0257   std::map<unsigned int, unsigned int>::iterator piter0, piter1, piter2;
0258   for (graniter = granulepacketlimits.begin(); graniter != granulepacketlimits.end(); ++graniter)
0259   {
0260     name = graniter->first;
0261     lolim = graniter->second.first;
0262     hilim = graniter->second.second;
0263     piter1 = packetsize.lower_bound(lolim);
0264     if (piter1->first < hilim)
0265     {
0266       if (verbosity > 0)
0267       {
0268         piter2 = packetsize.upper_bound(hilim);
0269         --piter2;
0270         std::cout << "Name: " << name << " first packet: " << piter1->first
0271              << " last packet: " << piter2->first << std::endl;
0272       }
0273     }
0274     else
0275     {
0276       if (verbosity > 0)
0277       {
0278         std::cout << "Name: " << name << " No packet found" << std::endl;
0279       }
0280       continue;
0281     }
0282     for (piter0 = piter1; piter0 != packetsize.upper_bound(hilim); ++piter0)
0283     {
0284       granpackets[piter0->first] = piter0->second;
0285     }
0286     db->AddRow(name, runno, nevnts, granpackets);
0287     packetsize.erase(packetsize.lower_bound(lolim), packetsize.upper_bound(hilim));
0288     granpackets.clear();
0289   }
0290   if (packetsize.size() > 0)
0291   {
0292     std::cout << "Non assigned packets found" << std::endl;
0293     for (piter0 = packetsize.begin(); piter0 != packetsize.end(); ++piter0)
0294     {
0295       std::cout << "Packet ID: " << piter0->first << std::endl;
0296     }
0297     std::ostringstream errmsg;
0298     errmsg << "PktSizeMon::UpdateDB() unassigned packets found:";
0299     for (piter0 = packetsize.begin(); piter0 != packetsize.end(); ++piter0)
0300     {
0301       errmsg << " " << piter0->first;
0302     }
0303     OnlMonServer *se = OnlMonServer::instance();
0304     se->send_message(this, MSG_SOURCE_DAQMON, MSG_SEV_ERROR, errmsg.str(), 2);
0305     db->AddRow("nogran", runno, nevnts, packetsize);
0306   }
0307   packetsize.clear();
0308   return 0;
0309 }