src/Draw/Draw_BasicCommands.cxx

   1 // Created on: 1995-02-23
   2 // Created by: Remi LEQUETTE
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21
  22 #include <Standard_Macro.hxx>
  23 #include <Standard_Stream.hxx>
  24 #include <Standard_SStream.hxx>
  25
  26 #include <Draw.ixx>
  27 #include <Draw_Appli.hxx>
  28 #include <Draw_Printer.hxx>
  29
  30 #include <Message.hxx>
  31 #include <Message_Messenger.hxx>
  32 #include <OSD_MemInfo.hxx>
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include <config.h>
  36 #endif
  37
  38 #if defined(HAVE_TIME_H) || defined(WNT)
  39 # include <time.h>
  40 #endif
  41
  42 #ifdef HAVE_SIGNAL_H
  43 # include <signal.h>
  44 #endif
  45
  46 #ifndef WNT
  47 # include <sys/resource.h>
  48 # ifdef HAVE_STRINGS_H
  49 #  include <strings.h>
  50 # endif
  51 #else
  52 //WNT
  53 extern Standard_Boolean Draw_Batch;
  54 #include <windows.h>
  55 #include <winbase.h>
  56 #include <process.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #ifdef HAVE_LIMITS
  60 # include <limits>
  61 #elif defined (HAVE_LIMITS_H)
  62 # include <limits.h>
  63 #endif
  64
  65 #ifdef WNT
  66 # include <limits>
  67 #endif
  68
  69 static clock_t MDTV_CPU_LIMIT;   // Cpu_limit in Sec.
  70 static clock_t MDTV_CPU_CURRENT; // cpu time already used at last
  71                                  // cpulimit call. (sec.)
  72 //#define strcasecmp strcmp Already defined
  73 #define RLIM_INFINITY   0x7fffffff
  74 #endif
  75
  76 #include <Draw_Chronometer.hxx>
  77 #include <OSD_MAllocHook.hxx>
  78 #include <OSD_Chronometer.hxx>
  79
  80 #if defined (__hpux) || defined ( HPUX )
  81 #define RLIM_INFINITY   0x7fffffff
  82 #define RLIMIT_CPU      0
  83 #endif
  84
  85
  86
  87 //=======================================================================
  88 // chronom
  89 //=======================================================================
  90
  91 extern Standard_Boolean Draw_Chrono;
  92
  93 static Standard_Integer chronom(Draw_Interpretor& di,
  94                                 Standard_Integer n,const char** a)
  95 {
  96   if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
  97     if (n == 1)
  98       Draw_Chrono = !Draw_Chrono;
  99     else
 100       Draw_Chrono = (*a[1] == '1');
 101
 102     if (Draw_Chrono) di << "Chronometers activated."<<"\n";
 103     else di << "Chronometers desactivated."<<"\n";
 104   }
 105   else {
 106     Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
 107     Handle(Draw_Chronometer) C;
 108     if (!D.IsNull()) {
 109       C = Handle(Draw_Chronometer)::DownCast(D);
 110     }
 111     if (C.IsNull()) {
 112       C = new Draw_Chronometer();
 113     Draw::Set(a[1],C,Standard_False);
 114     }
 115     if (n <= 2) {
 116       C->Timer().Reset();
 117     }
 118     else {
 119       if (!strcasecmp(a[2],"reset"))
 120         C->Timer().Reset();
 121       if (!strcasecmp(a[2],"start"))
 122         C->Timer().Start();
 123       if (!strcasecmp(a[2],"stop"))
 124         C->Timer().Stop();
 125       if (!strcasecmp(a[2],"show"))
 126         C->Timer().Show();
 127     }
 128   }
 129   return 0;
 130 }
 131
 132 static Standard_Integer dchronom(Draw_Interpretor& I,
 133                                  Standard_Integer n,const char** a)
 134 {
 135   if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
 136     if (n == 1)
 137       Draw_Chrono = !Draw_Chrono;
 138     else
 139       Draw_Chrono = (*a[1] == '1');
 140
 141     if (Draw_Chrono) I << "Chronometers activated."<<"\n";
 142     else I << "Chronometers desactivated."<<"\n";
 143   }
 144   else {
 145     Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
 146     Handle(Draw_Chronometer) C;
 147     if (!D.IsNull()) {
 148       C = Handle(Draw_Chronometer)::DownCast(D);
 149     }
 150     if (C.IsNull()) {
 151       C = new Draw_Chronometer();
 152     Draw::Set(a[1],C,Standard_False);
 153     }
 154     if (n <= 2) {
 155       C->Timer().Reset();
 156     }
 157     else {
 158       if (!strcasecmp(a[2],"reset"))
 159         C->Timer().Reset();
 160       if (!strcasecmp(a[2],"start"))
 161         C->Timer().Start();
 162       if (!strcasecmp(a[2],"stop"))
 163         C->Timer().Stop();
 164       if (!strcasecmp(a[2],"show")) {
 165         Standard_SStream ss;
 166         C->Timer().Show(ss);
 167         I << ss;
 168       }
 169     }
 170   }
 171   return 0;
 172 }
 173
 174
 175
 176 //=======================================================================
 177 //function : ifbatch
 178 //purpose  :
 179 //=======================================================================
 180
 181 static Standard_Integer ifbatch(Draw_Interpretor& DI, Standard_Integer , const char** )
 182 {
 183   if (Draw_Batch)
 184     DI << "1";
 185   else
 186     DI << "0";
 187
 188   return 0;
 189 }
 190
 191 //=======================================================================
 192 //function : spy
 193 //purpose  :
 194 //=======================================================================
 195
 196 extern Standard_Boolean Draw_Spying;
 197 extern filebuf Draw_Spyfile;
 198
 199 static Standard_Integer spy(Draw_Interpretor& di, Standard_Integer n, const char** a)
 200 {
 201   if (Draw_Spying)
 202     Draw_Spyfile.close();
 203   Draw_Spying = Standard_False;
 204   if (n > 1) {
 205     if (!Draw_Spyfile.open(a[1],ios::out)) {
 206       di << "Cannot open "<<a[1]<<" for writing"<<"\n";
 207       return 1;
 208     }
 209     Draw_Spying = Standard_True;
 210   }
 211   return 0;
 212 }
 213
 214 //=======================================================================
 215 //function : wait
 216 //purpose  :
 217 //=======================================================================
 218
 219 static Standard_Integer Draw_wait(Draw_Interpretor& , Standard_Integer n, const char** a)
 220 {
 221   Standard_Integer w = 10;
 222   if (n > 1)
 223     w = atoi(a[1]);
 224   time_t ct = time(NULL) + w;
 225   while (time(NULL) < ct) {};
 226   return 0;
 227 }
 228
 229 //=======================================================================
 230 //function : cpulimit
 231 //purpose  :
 232 //=======================================================================
 233 #ifdef WNT
 234 static unsigned int __stdcall CpuFunc (void * param)
 235 {
 236   clock_t aCurrent;
 237   while (1)
 238   {
 239     Sleep (5);
 240     Standard_Real anUserSeconds, aSystemSeconds;
 241     OSD_Chronometer::GetProcessCPU (anUserSeconds, aSystemSeconds);
 242     aCurrent = clock_t(anUserSeconds + aSystemSeconds);
 243
 244     if ((aCurrent - MDTV_CPU_CURRENT) >= MDTV_CPU_LIMIT)
 245     {
 246       printf ("CpuFunc : Fin sur Cpu Limit \n");
 247       ExitProcess (2);
 248       return 0;
 249     }
 250   }
 251   return 0;
 252 }
 253 #endif
 254
 255 static Standard_Integer cpulimit(Draw_Interpretor& di, Standard_Integer n, const char** a)
 256 {
 257 #ifndef WNT
 258   rlimit rlp;
 259   rlp.rlim_max = RLIM_INFINITY;
 260   if (n <= 1)
 261     rlp.rlim_cur = RLIM_INFINITY;
 262   else
 263     rlp.rlim_cur = atoi(a[1]);
 264
 265   int status;
 266   status=setrlimit(RLIMIT_CPU,&rlp);
 267   if (status !=0)
 268     di << "status cpulimit setrlimit : " << status << "\n";
 269
 270 #else
 271 //WNT
 272   static int aFirst = 1;
 273
 274   unsigned int __stdcall CpuFunc (void *);
 275   unsigned aThreadID;
 276
 277   if (n <= 1)
 278     MDTV_CPU_LIMIT = RLIM_INFINITY;
 279   else
 280   {
 281     MDTV_CPU_LIMIT = atoi (a[1]);
 282     Standard_Real anUserSeconds, aSystemSeconds;
 283     OSD_Chronometer::GetProcessCPU (anUserSeconds, aSystemSeconds);
 284     MDTV_CPU_CURRENT = clock_t(anUserSeconds + aSystemSeconds);
 285
 286     if (aFirst) // Launch the thread only at the 1st call.
 287     {
 288       aFirst = 0;
 289       _beginthreadex (NULL, 0, CpuFunc, NULL, 0, &aThreadID);
 290     }
 291   }
 292
 293 #endif
 294
 295   return 0;
 296 }
 297
 298 //=======================================================================
 299 //function : mallochook
 300 //purpose  :
 301 //=======================================================================
 302
 303 static Standard_Integer mallochook(Draw_Interpretor& di, Standard_Integer n,
 304                                    const char** a)
 305 {
 306   if (n < 2)
 307   {
 308     di << "\
 309 usage: mallochook cmd\n\
 310 where cmd is one of:\n\
 311   set [<op>]      - set callback to malloc/free; op is one of the following:\n\
 312                     0 - set callback to NULL,\n\
 313                     1 - set callback OSD_MAllocHook::CollectBySize (default)\n\
 314                     2 - set callback OSD_MAllocHook::LogFileHandler\n\
 315   reset           - reset the CollectBySize handler\n\
 316   report1 [<outfile>]\n\
 317                   - write report from CollectBySize handler in <outfile>\n\
 318   open [<logfile>]\n\
 319                   - open file for writing the log with LogFileHandler\n\
 320   close           - close the log file with LogFileHandler\n\
 321   report2 [<flag>] [<logfile>] [<outfile>]\n\
 322                   - scan <logfile> written with LogFileHandler\n\
 323                     and make synthesized report in <outfile>; <flag> can be:\n\
 324                     0 - simple stats by sizes (default),\n\
 325                     1 - with alive allocation numbers\n\
 326 By default <logfile> is \"mem-log.txt\", <outfile> is \"mem-stat.txt\""
 327       << "\n";
 328     return 0;
 329   }
 330   if (strcmp(a[1], "set") == 0)
 331   {
 332     int aType = (n > 2 ? atoi(a[2]) : 1);
 333     if (aType < 0 || aType > 2)
 334     {
 335       di << "unknown op of the command set" << "\n";
 336       return 1;
 337     }
 338     else if (aType == 0)
 339     {
 340       OSD_MAllocHook::SetCallback(NULL);
 341       di << "callback is unset" << "\n";
 342     }
 343     else if (aType == 1)
 344     {
 345       OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetCollectBySize());
 346       di << "callback is set to CollectBySize" << "\n";
 347     }
 348     else //if (aType == 2)
 349     {
 350       OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetLogFileHandler());
 351       di << "callback is set to LogFileHandler" << "\n";
 352     }
 353   }
 354   else if (strcmp(a[1], "reset") == 0)
 355   {
 356     OSD_MAllocHook::GetCollectBySize()->Reset();
 357     di << "CollectBySize handler is reset" << "\n";
 358   }
 359   else if (strcmp(a[1], "open") == 0)
 360   {
 361     const char* aFileName = (n > 2 ? a[2] : "mem-log.txt");
 362     if (!OSD_MAllocHook::GetLogFileHandler()->Open(aFileName))
 363     {
 364       di << "cannot create file " << aFileName << " for writing" << "\n";
 365       return 1;
 366     }
 367     di << "log file " << aFileName << " is opened for writing" << "\n";
 368   }
 369   else if (strcmp(a[1], "close") == 0)
 370   {
 371     OSD_MAllocHook::GetLogFileHandler()->Close();
 372     di << "log file is closed" << "\n";
 373   }
 374   else if (strcmp(a[1], "report1") == 0)
 375   {
 376     const char* aOutFile = "mem-stat.txt";
 377     if (n > 2)
 378       aOutFile = a[2];
 379     if (OSD_MAllocHook::GetCollectBySize()->MakeReport(aOutFile))
 380     {
 381       di << "report " << aOutFile << " has been created" << "\n";
 382     }
 383     else
 384     {
 385       di << "cannot create report " << aOutFile << "\n";
 386       return 1;
 387     }
 388   }
 389   else if (strcmp(a[1], "report2") == 0)
 390   {
 391     Standard_Boolean includeAlive = Standard_False;
 392     const char* aLogFile = "mem-log.txt";
 393     const char* aOutFile = "mem-stat.txt";
 394     if (n > 2)
 395     {
 396       includeAlive = (atoi(a[2]) != 0);
 397       if (n > 3)
 398       {
 399         aLogFile = a[3];
 400         if (n > 4)
 401           aOutFile = a[4];
 402       }
 403     }
 404     if (OSD_MAllocHook::LogFileHandler::MakeReport(aLogFile, aOutFile, includeAlive))
 405     {
 406       di << "report " << aOutFile << " has been created" << "\n";
 407     }
 408     else
 409     {
 410       di << "cannot create report " << aOutFile << " from the log file "
 411         << aLogFile << "\n";
 412       return 1;
 413     }
 414   }
 415   else
 416   {
 417     di << "unrecognized command " << a[1] << "\n";
 418     return 1;
 419   }
 420   return 0;
 421 }
 422
 423 //==============================================================================
 424 //function : dmeminfo
 425 //purpose  :
 426 //==============================================================================
 427
 428 static int dmeminfo (Draw_Interpretor& theDI,
 429                      Standard_Integer  theArgNb,
 430                      const char**      theArgVec)
 431 {
 432   OSD_MemInfo aMemInfo;
 433   if (theArgNb <= 1)
 434   {
 435     theDI << aMemInfo.ToString();
 436     return 0;
 437   }
 438
 439   for (Standard_Integer anIter = 1; anIter < theArgNb; ++anIter)
 440   {
 441     TCollection_AsciiString anArg (theArgVec[anIter]);
 442     anArg.LowerCase();
 443     if (anArg == "virt" || anArg == "v")
 444     {
 445       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemVirtual)) << " ";
 446     }
 447     else if (anArg == "wset" || anArg == "w")
 448     {
 449       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemWorkingSet)) << " ";
 450     }
 451     else if (anArg == "wsetpeak")
 452     {
 453       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemWorkingSetPeak)) << " ";
 454     }
 455     else if (anArg == "swap")
 456     {
 457       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemSwapUsage)) << " ";
 458     }
 459     else if (anArg == "swappeak")
 460     {
 461       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemSwapUsagePeak)) << " ";
 462     }
 463     else if (anArg == "private")
 464     {
 465       theDI << Standard_Real (aMemInfo.Value (OSD_MemInfo::MemPrivate)) << " ";
 466     }
 467     else
 468     {
 469       std::cerr << "Unknown argument '" << theArgVec[anIter] << "'!\n";
 470     }
 471   }
 472   theDI << "\n";
 473   return 0;
 474 }
 475
 476 void Draw::BasicCommands(Draw_Interpretor& theCommands)
 477 {
 478   static Standard_Boolean Done = Standard_False;
 479   if (Done) return;
 480   Done = Standard_True;
 481
 482   const char* g = "DRAW General Commands";
 483
 484   theCommands.Add("batch", "returns 1 in batch mode",
 485                   __FILE__,ifbatch,g);
 486   theCommands.Add("spy","spy [file], Save commands in file. no file close",
 487                   __FILE__,spy,g);
 488   theCommands.Add("wait","wait [time(10)], wait time seconds",
 489                   __FILE__,Draw_wait,g);
 490   theCommands.Add("cpulimit","cpulimit [nbseconds], no args remove limits",
 491                   __FILE__,cpulimit,g);
 492   theCommands.Add("chrono","chrono [ name start/stop/reset/show]",
 493                   __FILE__,chronom,g);
 494   theCommands.Add("dchrono","dchrono [ name start/stop/reset/show]",
 495                   __FILE__,dchronom,g);
 496   theCommands.Add("mallochook",
 497                   "debug memory allocation/deallocation, w/o args for help",
 498                   __FILE__, mallochook, g);
 499   theCommands.Add ("meminfo",
 500     "meminfo [virt|v] [wset|w] [wsetpeak] [swap] [swappeak] [private]"
 501     " : memory counters for this process",
 502           __FILE__, dmeminfo, g);
 503 }