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