0030904: Visualization - OSD_MemInfo provide Update with parameter of computation...
[occt.git] / 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-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Draw.hxx>
19 #include <Draw_Appli.hxx>
20 #include <Draw_Chronometer.hxx>
21 #include <Draw_Drawable3D.hxx>
22 #include <Draw_Printer.hxx>
23 #include <Draw_ProgressIndicator.hxx>
24 #include <Message.hxx>
25 #include <Message_Messenger.hxx>
26 #include <OSD.hxx>
27 #include <OSD_Chronometer.hxx>
28 #include <OSD_Environment.hxx>
29 #include <OSD_Exception_CTRL_BREAK.hxx>
30 #include <OSD_MAllocHook.hxx>
31 #include <OSD_MemInfo.hxx>
32 #include <OSD_Parallel.hxx>
33 #include <OSD_ThreadPool.hxx>
34 #include <Standard_Macro.hxx>
35 #include <Standard_SStream.hxx>
36 #include <Standard_Stream.hxx>
37 #include <Standard_Version.hxx>
38 #include <TCollection_AsciiString.hxx>
39
40 #include <OSD_PerfMeter.h>
41 #ifdef _WIN32
42
43 #include <windows.h>
44 #include <winbase.h>
45 #include <process.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <time.h>
49 #include <limits>
50
51 #define RLIM_INFINITY   0x7fffffff
52
53 static clock_t CPU_CURRENT; // cpu time already used at last
54                             // cpulimit call. (sec.) 
55 #else /* _WIN32 */
56
57 #include <sys/resource.h>
58 #include <signal.h>
59 #include <unistd.h>
60
61 #if defined (__hpux) || defined ( HPUX )
62 #define RLIM_INFINITY   0x7fffffff
63 #define RLIMIT_CPU      0
64 #endif
65
66 #endif /* _WIN32 */
67
68 extern Standard_Boolean Draw_Batch;
69
70 static clock_t CPU_LIMIT;   // Cpu_limit in Sec.
71 static OSD_Timer aTimer;
72
73 //=======================================================================
74 // chronom
75 //=======================================================================
76
77 extern Standard_Boolean Draw_Chrono;
78
79 static Standard_Integer chronom(Draw_Interpretor& di,
80                                 Standard_Integer n,const char** a)
81 {
82   if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
83     if (n == 1)
84       Draw_Chrono = !Draw_Chrono;
85     else
86       Draw_Chrono = (*a[1] == '1');
87
88     if (Draw_Chrono) di << "Chronometers activated.\n";
89     else di << "Chronometers desactivated.\n";
90   }
91   else {
92     Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
93     Handle(Draw_Chronometer) C;
94     if (!D.IsNull()) {
95       C = Handle(Draw_Chronometer)::DownCast(D);
96     }
97     if (C.IsNull()) {
98       C = new Draw_Chronometer();
99     Draw::Set(a[1],C,Standard_False);
100     }
101     if (n <= 2) {
102       C->Timer().Reset();
103     }
104     else {
105       for (Standard_Integer anIter = 2; anIter < n; ++anIter)
106       {
107         TCollection_AsciiString anArg (a[anIter]);
108         anArg.LowerCase();
109
110         if (anArg == "reset")
111         {
112           C->Timer().Reset();
113         }
114         else if (anArg == "restart")
115         {
116           C->Timer().Restart();
117         }
118         else if (anArg == "start")
119         {
120           C->Timer().Start();
121         }
122         else if (anArg == "stop")
123         {
124           C->Timer().Stop();
125         }
126         else if (anArg == "show")
127         {
128           C->Timer().Show();
129         }
130         else if (anArg == "counter")
131         {
132           Standard_Real aSeconds,aCPUtime;
133           Standard_Integer aMinutes, aHours;
134           C->Timer().Show(aSeconds,aMinutes,aHours,aCPUtime);
135           std::cout << "COUNTER " << a[++anIter] << ": " << aCPUtime << "\n";
136         }
137         else
138         {
139           std::cerr << "Unknown argument '" << a[anIter] << "'!\n";
140         }
141       }
142     }
143   }
144   return 0;
145 }
146
147 static Standard_Integer dchronom(Draw_Interpretor& theDI,
148                                  Standard_Integer n,const char** a)
149 {
150   if ((n == 1) || (*a[1] == '0') || (*a[1] == '1')) {
151     if (n == 1)
152       Draw_Chrono = !Draw_Chrono;
153     else
154       Draw_Chrono = (*a[1] == '1');
155
156     if (Draw_Chrono) theDI << "Chronometers activated.\n";
157     else theDI << "Chronometers desactivated.\n";
158   }
159   else {
160     Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
161     Handle(Draw_Chronometer) C;
162     if (!D.IsNull()) {
163       C = Handle(Draw_Chronometer)::DownCast(D);
164     }
165     if (C.IsNull()) {
166       C = new Draw_Chronometer();
167       Draw::Set(a[1],C,Standard_False);
168     }
169     if (n <= 2) {
170       C->Timer().Reset();
171     }
172     else {
173       for (Standard_Integer anIter = 2; anIter < n; ++anIter)
174       {
175         TCollection_AsciiString anArg (a[anIter]);
176         anArg.LowerCase();
177
178         if (anArg == "reset")
179         {
180           C->Timer().Reset();
181         }
182         else if (anArg == "restart")
183         {
184           C->Timer().Restart();
185         }
186         else if (anArg == "start")
187         {
188           C->Timer().Start();
189         }
190         else if (anArg == "stop")
191         {
192           C->Timer().Stop();
193         }
194         else if (anArg == "show")
195         {
196           Standard_SStream ss;
197           C->Timer().Show(ss);
198           theDI << ss;
199         }
200         else if (anArg == "counter")
201         {
202           Standard_Real aSeconds,aCPUtime;
203           Standard_Integer aMinutes, aHours;
204           C->Timer().Show(aSeconds,aMinutes,aHours,aCPUtime);
205           theDI << "COUNTER " << a[++anIter] << ": " << aCPUtime << "\n";
206         }
207         else
208         {
209           theDI << "Unknown argument '" << a[anIter] << "'!\n";
210         }
211       }
212     }
213   }
214   return 0;
215 }
216
217
218
219 //=======================================================================
220 //function : ifbatch
221 //purpose  : 
222 //=======================================================================
223
224 static Standard_Integer ifbatch(Draw_Interpretor& DI, Standard_Integer , const char** )
225 {
226   if (Draw_Batch)
227     DI << "1";
228   else
229     DI << "0";
230   
231   return 0;
232 }
233
234 //=======================================================================
235 //function : spy
236 //purpose  : 
237 //=======================================================================
238
239 extern Standard_Boolean Draw_Spying;
240 extern std::filebuf Draw_Spyfile;
241
242 static Standard_Integer spy(Draw_Interpretor& di, Standard_Integer n, const char** a)
243 {
244   if (Draw_Spying) 
245     Draw_Spyfile.close();
246   Draw_Spying = Standard_False;
247   if (n > 1) {
248     if (!Draw_Spyfile.open(a[1],std::ios::out)) {
249       di << "Cannot open "<<a[1]<<" for writing\n";
250       return 1;
251     }
252     Draw_Spying = Standard_True;
253   }
254   return 0;
255 }
256
257 static Standard_Integer dlog(Draw_Interpretor& di, Standard_Integer n, const char** a)
258 {
259   if (n != 2 && n != 3)
260   {
261     std::cout << "Enable or disable logging: " << a[0] << " {on|off}" << std::endl;
262     std::cout << "Reset log: " << a[0] << " reset" << std::endl;
263     std::cout << "Get log content: " << a[0] << " get" << std::endl;
264     return 1;
265   }
266
267   if (! strcmp (a[1], "on") && n == 2)
268   {
269     di.SetDoLog (Standard_True);
270 //    di.Log() << "dlog on" << std::endl; // for symmetry
271   }
272   else if (! strcmp (a[1], "off") && n == 2)
273   {
274     di.SetDoLog (Standard_False);
275   }
276   else if (! strcmp (a[1], "reset") && n == 2)
277   {
278     di.ResetLog();
279   }
280   else if (! strcmp (a[1], "get") && n == 2)
281   {
282     di << di.GetLog();
283   }
284   else if (! strcmp (a[1], "add") && n == 3)
285   {
286     di.AddLog (a[2]);
287     di.AddLog ("\n");
288   }
289   else if (! strcmp (a[1], "status") && n == 2)
290   {
291     di << (di.GetDoLog() ? "on" : "off");
292   }
293   else {
294     std::cout << "Unrecognized option(s): " << a[1] << std::endl;
295     return 1;
296   }
297   return 0;
298 }
299
300 static Standard_Integer decho(Draw_Interpretor& di, Standard_Integer n, const char** a)
301 {
302   if (n != 2)
303   {
304     std::cout << "Enable or disable echoing: " << a[0] << " {on|off}" << std::endl;
305     return 1;
306   }
307
308   if (! strcmp (a[1], "on"))
309   {
310     di.SetDoEcho (Standard_True);
311   }
312   else if (! strcmp (a[1], "off"))
313   {
314     di.SetDoEcho (Standard_False);
315   }
316   else {
317     std::cout << "Unrecognized option: " << a[1] << std::endl;
318     return 1;
319   }
320   return 0;
321 }
322
323 static Standard_Integer dbreak(Draw_Interpretor& di, Standard_Integer, const char**)
324 {
325   try {
326     OSD::ControlBreak();
327   }
328   catch (OSD_Exception_CTRL_BREAK const&) {
329     di << "User pressed Control-Break";
330     return 1; // Tcl exception
331   }
332
333   return 0;
334 }
335
336 static Standard_Integer dversion(Draw_Interpretor& di, Standard_Integer, const char**)
337 {
338   // print OCCT version and OCCTY-specific macros used
339   di << "Open CASCADE Technology " << OCC_VERSION_STRING_EXT << "\n";
340 #ifdef OCCT_DEBUG
341   di << "Extended debug mode\n";
342 #elif defined(_DEBUG)
343   di << "Debug mode\n";
344 #endif
345 #ifdef HAVE_TBB
346   di << "TBB enabled (HAVE_TBB)\n";
347 #else 
348   di << "TBB disabled\n";
349 #endif
350 #ifdef HAVE_FREEIMAGE
351   di << "FreeImage enabled (HAVE_FREEIMAGE)\n";
352 #else
353   di << "FreeImage disabled\n";
354 #endif
355 #ifdef HAVE_FFMPEG
356   di << "FFmpeg enabled (HAVE_FFMPEG)\n";
357 #else
358   di << "FFmpeg disabled\n";
359 #endif
360 #ifdef HAVE_GLES2
361   di << "OpenGL: ES2\n";
362 #else
363   di << "OpenGL: desktop\n";
364 #endif
365 #ifdef HAVE_RAPIDJSON
366   di << "RapidJSON enabled (HAVE_RAPIDJSON)\n";
367 #else
368   di << "RapidJSON disabled\n";
369 #endif
370 #ifdef HAVE_VTK
371   di << "VTK enabled (HAVE_VTK)\n";
372 #else
373   di << "VTK disabled\n";
374 #endif
375 #ifdef No_Exception
376   di << "Exceptions disabled (No_Exception)\n";
377 #else
378   di << "Exceptions enabled\n";
379 #endif
380
381   // check compiler, OS, etc. using pre-processor macros provided by compiler
382   // see "Pre-defined C/C++ Compiler Macros" http://sourceforge.net/p/predef/wiki/
383   // note that only modern compilers that are known to be used for OCCT are recognized
384
385   // compiler; note that GCC and MSVC are last as other compilers (e.g. Intel) can also define __GNUC__ and _MSC_VER
386 #if defined(__INTEL_COMPILER)
387   di << "Compiler: Intel " << __INTEL_COMPILER << "\n";
388 #elif defined(__BORLANDC__)
389   di << "Compiler: Borland C++ (__BORLANDC__ = " << __BORLANDC__ << ")\n";
390 #elif defined(__clang__)
391   di << "Compiler: Clang " << __clang_major__ << "." << __clang_minor__ << "." << __clang_patchlevel__ << "\n";
392 #elif defined(__SUNPRO_C)
393   di << "Compiler: Sun Studio (__SUNPRO_C = " << __SUNPROC_C << ")\n";
394 #elif defined(_MSC_VER)
395   #if _MSC_VER < 1900
396     di << "Compiler: MS Visual C++ " << (int)(_MSC_VER/100-6) << "." << (int)((_MSC_VER/10)-60-10*(int)(_MSC_VER/100-6)) << " (_MSC_FULL_VER = " << _MSC_FULL_VER << ")\n";
397   #else
398     di << "Compiler: MS Visual C++ " << (int)(_MSC_VER/100-5) << "." << (int)((_MSC_VER/10)-50-10*(int)(_MSC_VER/100-5)) << " (_MSC_FULL_VER = " << _MSC_FULL_VER << ")\n";
399   #endif
400 #elif defined(__GNUC__)
401   di << "Compiler: GCC " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__ << "\n";
402 #else
403   di << "Compiler: unrecognized\n";
404 #endif
405
406   // Cygwin and MinGW specifics
407 #if defined(__CYGWIN__)
408   di << "Cygwin\n";
409 #endif
410 #if defined(__MINGW64__)
411   di << "MinGW 64 " << __MINGW64_VERSION_MAJOR << "." << __MINGW64_VERSION_MINOR << "\n";
412 #elif defined(__MINGW32__)
413   di << "MinGW 32 " << __MINGW32_MAJOR_VERSION << "." << __MINGW32_MINOR_VERSION << "\n";
414 #endif 
415
416   // architecture
417 #if defined(__amd64) || defined(__x86_64) || defined(_M_AMD64)
418   di << "Architecture: AMD64\n";
419 #elif defined(__i386) || defined(_M_IX86) || defined(__X86__)|| defined(_X86_)
420   di << "Architecture: Intel x86\n";
421 #elif defined(_M_IA64) || defined(__ia64__)
422   di << "Architecture: Intel Itanium (IA 64)\n";
423 #elif defined(__sparc__) || defined(__sparc)
424   di << "Architecture: SPARC\n";
425 #else
426   di << "Architecture: unrecognized\n";
427 #endif
428
429   // OS
430 #if defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
431   di << "OS: Windows\n";
432 #elif defined(__APPLE__) || defined(__MACH__)
433   di << "OS: Mac OS X\n";
434 #elif defined(__sun) 
435   di << "OS: SUN Solaris\n";
436 #elif defined(__ANDROID__) /* must be before Linux */
437   #include <android/api-level.h>
438   di << "OS: Android (__ANDROID_API__ = " << __ANDROID_API__ << ")\n";
439 #elif defined(__QNXNTO__)
440   di << "OS: QNX Neutrino\n";
441 #elif defined(__QNX__)
442   di << "OS: QNX\n";
443 #elif defined(__linux__)
444   di << "OS: Linux\n";
445 #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
446   #include <sys/param.h>
447   di << "OS: BSD (BSD = " << BSD << ")\n";
448 #else
449   di << "OS: unrecognized\n";
450 #endif
451
452   return 0;
453 }
454
455 //=======================================================================
456 //function : wait
457 //purpose  : 
458 //=======================================================================
459
460 static Standard_Integer Draw_wait(Draw_Interpretor& , Standard_Integer n, const char** a)
461 {
462   Standard_Integer w = 10;
463   if (n > 1)
464     w = Draw::Atoi(a[1]);
465   time_t ct = time(NULL) + w;
466   while (time(NULL) < ct) {};
467   return 0;
468 }
469
470 //=======================================================================
471 //function : cpulimit
472 //purpose  : 
473 //=======================================================================
474 #ifdef _WIN32
475 static unsigned int __stdcall CpuFunc (void * /*param*/)
476 {
477   clock_t anElapCurrent;
478   clock_t aCurrent;
479
480   for(;;)
481   {
482     Sleep (5);
483     Standard_Real anUserSeconds, aSystemSeconds;
484     OSD_Chronometer::GetProcessCPU (anUserSeconds, aSystemSeconds);
485     aCurrent = clock_t(anUserSeconds + aSystemSeconds);
486     anElapCurrent = clock_t(aTimer.ElapsedTime());
487     
488     if (CPU_LIMIT > 0 && (aCurrent - CPU_CURRENT) >= CPU_LIMIT)
489     {
490       aTimer.Stop();
491       if (IsDebuggerPresent())
492       {
493         std::cout << "Info: CPU limit (" << CPU_LIMIT << " sec) has been reached but ignored because of attached Debugger" << std::endl;
494         return 0;
495       }
496       else
497       {
498         std::cout << "ERROR: Process killed by CPU limit (" << CPU_LIMIT << " sec)" << std::endl;
499         ExitProcess (2);
500       }
501     }
502     if (CPU_LIMIT > 0 && anElapCurrent >= CPU_LIMIT)
503     {
504       aTimer.Stop();
505       if (IsDebuggerPresent())
506       {
507         std::cout << "Info: Elapsed limit (" << CPU_LIMIT << " sec) has been reached but ignored because of attached Debugger" << std::endl;
508         return 0;
509       }
510       else
511       {
512         std::cout << "ERROR: Process killed by elapsed limit (" << CPU_LIMIT << " sec)" << std::endl;
513         ExitProcess (2);
514       }
515     }
516   }
517 }
518 #else
519 static void cpulimitSignalHandler (int)
520 {
521   std::cout << "Process killed by CPU limit  (" << CPU_LIMIT << " sec)" << std::endl;
522   exit(2);
523 }
524 static void *CpuFunc(void* /*threadarg*/)
525 {
526   clock_t anElapCurrent;
527   for(;;)
528   {
529     sleep (5);
530     anElapCurrent = clock_t(aTimer.ElapsedTime());
531     if (CPU_LIMIT >0 && (anElapCurrent) >= CPU_LIMIT) {
532       std::cout << "Process killed by elapsed limit  (" << CPU_LIMIT << " sec)" << std::endl;
533       exit(2);
534     }
535   }
536   return NULL;
537 }
538 #endif
539
540 // Returns time in seconds defined by the argument string,
541 // multiplied by factor defined in environment variable
542 // CSF_CPULIMIT_FACTOR (if it exists, 1 otherwise)
543 static clock_t GetCpuLimit (const Standard_CString theParam)
544 {
545   clock_t aValue = Draw::Atoi (theParam);
546
547   OSD_Environment aEnv("CSF_CPULIMIT_FACTOR");
548   TCollection_AsciiString aEnvStr = aEnv.Value();
549   if (!aEnvStr.IsEmpty())
550   {
551     aValue *= Draw::Atoi (aEnvStr.ToCString());
552   }
553   return aValue;
554 }
555
556 static Standard_Integer cpulimit(Draw_Interpretor& di, Standard_Integer n, const char** a)
557 {
558   static int aFirst = 1;
559 #ifdef _WIN32
560   // Windows specific code
561   unsigned int __stdcall CpuFunc (void *);
562   unsigned aThreadID;
563
564   if (n <= 1){
565     CPU_LIMIT = RLIM_INFINITY;
566   } else {
567     CPU_LIMIT = GetCpuLimit (a[1]);
568     Standard_Real anUserSeconds, aSystemSeconds;
569     OSD_Chronometer::GetProcessCPU (anUserSeconds, aSystemSeconds);
570     CPU_CURRENT = clock_t(anUserSeconds + aSystemSeconds);
571     aTimer.Reset();
572     aTimer.Start();
573     if (aFirst) // Launch the thread only at the 1st call.
574     {
575       aFirst = 0;
576       _beginthreadex (NULL, 0, CpuFunc, NULL, 0, &aThreadID);
577     }
578   }
579
580 #else 
581   // Unix & Linux
582   rlimit rlp;
583   rlp.rlim_max = RLIM_INFINITY;
584   if (n <= 1)
585     rlp.rlim_cur = RLIM_INFINITY;
586   else
587     rlp.rlim_cur = GetCpuLimit (a[1]);
588   CPU_LIMIT = rlp.rlim_cur;
589
590   int status;
591   status=setrlimit(RLIMIT_CPU,&rlp);
592   if (status !=0)
593     di << "status cpulimit setrlimit : " << status << "\n";
594
595   // set signal handler to print a message before death
596   struct sigaction act, oact;
597   memset (&act, 0, sizeof(act));
598   act.sa_handler = cpulimitSignalHandler;
599   sigaction (SIGXCPU, &act, &oact);
600
601   // cpulimit for elapsed time
602   aTimer.Reset();
603   aTimer.Start();
604   pthread_t cpulimitThread;
605   if (aFirst) // Launch the thread only at the 1st call.
606   {
607     aFirst = 0;
608     pthread_create(&cpulimitThread, NULL, CpuFunc, NULL);
609   }
610 #endif
611   di << "CPU and elapsed time limit set to " << (double)CPU_LIMIT << " seconds";
612   return 0;
613 }
614
615 //=======================================================================
616 //function : mallochook
617 //purpose  : 
618 //=======================================================================
619
620 static Standard_Integer mallochook(Draw_Interpretor& di, Standard_Integer n,
621                                    const char** a)
622 {
623   if (n < 2)
624   {
625     di << "\
626 usage: mallochook cmd\n\
627 where cmd is one of:\n\
628   set [<op>]      - set callback to malloc/free; op is one of the following:\n\
629                     0 - set callback to NULL,\n\
630                     1 - set callback OSD_MAllocHook::CollectBySize (default)\n\
631                     2 - set callback OSD_MAllocHook::LogFileHandler\n\
632   reset           - reset the CollectBySize handler\n\
633   report1 [<outfile>]\n\
634                   - write report from CollectBySize handler in <outfile>\n\
635   open [<logfile>]\n\
636                   - open file for writing the log with LogFileHandler\n\
637   close           - close the log file with LogFileHandler\n\
638   report2 [<flag>] [<logfile>] [<outfile>]\n\
639                   - scan <logfile> written with LogFileHandler\n\
640                     and make synthesized report in <outfile>; <flag> can be:\n\
641                     0 - simple stats by sizes (default),\n\
642                     1 - with alive allocation numbers\n\
643 By default <logfile> is \"mem-log.txt\", <outfile> is \"mem-stat.txt\""
644       << "\n";
645     return 0;
646   }
647   if (strcmp(a[1], "set") == 0)
648   {
649     int aType = (n > 2 ? Draw::Atoi(a[2]) : 1);
650     if (aType < 0 || aType > 2)
651     {
652       di << "unknown op of the command set\n";
653       return 1;
654     }
655     else if (aType == 0)
656     {
657       OSD_MAllocHook::SetCallback(NULL);
658       di << "callback is unset\n";
659     }
660     else if (aType == 1)
661     {
662       OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetCollectBySize());
663       di << "callback is set to CollectBySize\n";
664     }
665     else //if (aType == 2)
666     {
667       OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetLogFileHandler());
668       di << "callback is set to LogFileHandler\n";
669     }
670   }
671   else if (strcmp(a[1], "reset") == 0)
672   {
673     OSD_MAllocHook::GetCollectBySize()->Reset();
674     di << "CollectBySize handler is reset\n";
675   }
676   else if (strcmp(a[1], "open") == 0)
677   {
678     const char* aFileName = (n > 2 ? a[2] : "mem-log.txt");
679     if (!OSD_MAllocHook::GetLogFileHandler()->Open(aFileName))
680     {
681       di << "cannot create file " << aFileName << " for writing\n";
682       return 1;
683     }
684     di << "log file " << aFileName << " is opened for writing\n";
685   }
686   else if (strcmp(a[1], "close") == 0)
687   {
688     OSD_MAllocHook::GetLogFileHandler()->Close();
689     di << "log file is closed\n";
690   }
691   else if (strcmp(a[1], "report1") == 0)
692   {
693     const char* aOutFile = "mem-stat.txt";
694     if (n > 2)
695       aOutFile = a[2];
696     if (OSD_MAllocHook::GetCollectBySize()->MakeReport(aOutFile))
697     {
698       di << "report " << aOutFile << " has been created\n";
699     }
700     else
701     {
702       di << "cannot create report " << aOutFile << "\n";
703       return 1;
704     }
705   }
706   else if (strcmp(a[1], "report2") == 0)
707   {
708     Standard_Boolean includeAlive = Standard_False;
709     const char* aLogFile = "mem-log.txt";
710     const char* aOutFile = "mem-stat.txt";
711     if (n > 2)
712     {
713       includeAlive = (Draw::Atoi(a[2]) != 0);
714       if (n > 3)
715       {
716         aLogFile = a[3];
717         if (n > 4)
718           aOutFile = a[4];
719       }
720     }
721     if (OSD_MAllocHook::LogFileHandler::MakeReport(aLogFile, aOutFile, includeAlive))
722     {
723       di << "report " << aOutFile << " has been created\n";
724     }
725     else
726     {
727       di << "cannot create report " << aOutFile << " from the log file "
728         << aLogFile << "\n";
729       return 1;
730     }
731   }
732   else
733   {
734     di << "unrecognized command " << a[1] << "\n";
735     return 1;
736   }
737   return 0;
738 }
739
740 //==============================================================================
741 //function : dlocale
742 //purpose  :
743 //==============================================================================
744
745 static int dlocale (Draw_Interpretor& di, Standard_Integer n, const char** argv)
746 {
747   int category = LC_ALL;
748   if (n > 1)
749   {
750     const char *cat = argv[1];
751     if ( ! strcmp (cat, "LC_ALL") ) category = LC_ALL;
752     else if ( ! strcmp (cat, "LC_COLLATE") ) category = LC_COLLATE;
753     else if ( ! strcmp (cat, "LC_CTYPE") ) category = LC_CTYPE;
754     else if ( ! strcmp (cat, "LC_MONETARY") ) category = LC_MONETARY;
755     else if ( ! strcmp (cat, "LC_NUMERIC") ) category = LC_NUMERIC;
756     else if ( ! strcmp (cat, "LC_TIME") ) category = LC_TIME;
757     else 
758     {
759       std::cout << "Error: cannot recognize argument " << cat << " as one of LC_ macros" << std::endl;
760       return 1;
761     }
762   }
763   const char* locale = (n > 2 ? argv[2] : NULL);
764   const char* result = setlocale (category, locale);
765   if (result)
766     di << result;
767   else 
768     std::cout << "Error: unsupported locale specification: " << locale << std::endl;
769   return 0;
770 }
771
772 //==============================================================================
773 //function : dmeminfo
774 //purpose  :
775 //==============================================================================
776
777 static int dmeminfo (Draw_Interpretor& theDI,
778                      Standard_Integer  theArgNb,
779                      const char**      theArgVec)
780 {
781   if (theArgNb <= 1)
782   {
783     OSD_MemInfo aMemInfo;
784     theDI << aMemInfo.ToString();
785     return 0;
786   }
787
788   NCollection_Map<OSD_MemInfo::Counter> aCounters;
789   for (Standard_Integer anIter = 1; anIter < theArgNb; ++anIter)
790   {
791     TCollection_AsciiString anArg (theArgVec[anIter]);
792     anArg.LowerCase();
793     if (anArg == "virt" || anArg == "v")
794     {
795       aCounters.Add (OSD_MemInfo::MemVirtual);
796     }
797     else if (anArg == "heap" || anArg == "h")
798     {
799       aCounters.Add (OSD_MemInfo::MemHeapUsage);
800     }
801     else if (anArg == "wset" || anArg == "w")
802     {
803       aCounters.Add (OSD_MemInfo::MemWorkingSet);
804     }
805     else if (anArg == "wsetpeak")
806     {
807       aCounters.Add (OSD_MemInfo::MemWorkingSetPeak);
808     }
809     else if (anArg == "swap")
810     {
811       aCounters.Add (OSD_MemInfo::MemSwapUsage);
812     }
813     else if (anArg == "swappeak")
814     {
815       aCounters.Add (OSD_MemInfo::MemSwapUsagePeak);
816     }
817     else if (anArg == "private")
818     {
819       aCounters.Add (OSD_MemInfo::MemPrivate);
820     }
821     else
822     {
823       std::cerr << "Unknown argument '" << theArgVec[anIter] << "'!\n";
824     }
825   }
826
827   OSD_MemInfo aMemInfo (Standard_False);
828   aMemInfo.SetActive (Standard_False);
829   for (NCollection_Map<OSD_MemInfo::Counter>::Iterator aCountersIt (aCounters); aCountersIt.More(); aCountersIt.Next())
830   {
831     aMemInfo.SetActive (aCountersIt.Value(), Standard_True);
832   }
833   aMemInfo.Update();
834
835   for (NCollection_Map<OSD_MemInfo::Counter>::Iterator aCountersIt (aCounters); aCountersIt.More(); aCountersIt.Next())
836   {
837     theDI << Standard_Real (aMemInfo.Value (aCountersIt.Value())) << " ";
838   }
839   theDI << "\n";
840   return 0;
841 }
842
843 //==============================================================================
844 //function : dparallel
845 //purpose  :
846 //==============================================================================
847 static int dparallel (Draw_Interpretor& theDI,
848                       Standard_Integer  theArgNb,
849                       const char**      theArgVec)
850 {
851   const Handle(OSD_ThreadPool)& aDefPool = OSD_ThreadPool::DefaultPool();
852   if (theArgNb <= 1)
853   {
854     theDI << "NbLogicalProcessors: " << OSD_Parallel::NbLogicalProcessors() << "\n"
855           << "NbThreads:           " << aDefPool->NbThreads() << "\n"
856           << "NbDefThreads:        " << aDefPool->NbDefaultThreadsToLaunch() << "\n"
857           << "UseOcct:             " << (OSD_Parallel::ToUseOcctThreads() ? 1 : 0);
858     return 0;
859   }
860
861   for (Standard_Integer anIter = 1; anIter < theArgNb; ++anIter)
862   {
863     TCollection_AsciiString anArg (theArgVec[anIter]);
864     anArg.LowerCase();
865     if (anIter + 1 < theArgNb
866      && (anArg == "-nbthreads"
867       || anArg == "-threads"))
868     {
869       const Standard_Integer aVal = Draw::Atoi (theArgVec[++anIter]);
870       aDefPool->Init (aVal);
871     }
872     else if (anIter + 1 < theArgNb
873           && (anArg == "-nbdefthreads"
874            || anArg == "-defthreads"
875            || anArg == "-nbmaxdefthreads"
876            || anArg == "-maxdefthreads"))
877     {
878       const Standard_Integer aVal = Draw::Atoi (theArgVec[++anIter]);
879       if (aVal <= 0 || aVal > aDefPool->NbThreads())
880       {
881         std::cout << "Syntax error: maximum number of threads to use should be <= of threads in the pool\n";
882         return 1;
883       }
884       aDefPool->SetNbDefaultThreadsToLaunch (aVal);
885     }
886     else if (anIter + 1 < theArgNb
887           && (anArg == "-useocct"
888            || anArg == "-touseocct"
889            || anArg == "-occt"))
890     {
891       const Standard_Integer aVal = Draw::Atoi (theArgVec[++anIter]);
892       OSD_Parallel::SetUseOcctThreads (aVal == 1);
893       if (OSD_Parallel::ToUseOcctThreads() != (aVal == 1))
894       {
895         std::cout << "Warning: unable to switch threads library - no options available\n";
896       }
897     }
898     else if (anIter + 1 < theArgNb
899           && (anArg == "-usetbb"
900            || anArg == "-tousetbb"
901            || anArg == "-tbb"))
902     {
903       const Standard_Integer aVal = Draw::Atoi (theArgVec[++anIter]);
904       OSD_Parallel::SetUseOcctThreads (aVal == 0);
905       if (OSD_Parallel::ToUseOcctThreads() != (aVal == 0))
906       {
907         std::cout << "Warning: unable to switch threads library - no options available\n";
908       }
909     }
910     else
911     {
912       std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
913       return 1;
914     }
915   }
916   return 0;
917 }
918
919 //==============================================================================
920 //function : dperf
921 //purpose  :
922 //==============================================================================
923
924 static int dperf (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
925 {
926   // reset if argument is provided and it is not '0'
927   int reset = (theArgNb > 1 ? theArgVec[1][0] != '0' && theArgVec[1][0] != '\0' : 0);
928   char buffer[25600];
929   perf_sprint_all_meters (buffer, 25600 - 1, reset);
930   theDI << buffer;
931   return 0;
932 }
933
934 //==============================================================================
935 //function : dsetsignal
936 //purpose  :
937 //==============================================================================
938
939 static int dsetsignal (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
940 {
941   OSD_SignalMode aMode = OSD_SignalMode_Set;
942   Standard_Boolean aSetFPE = OSD::ToCatchFloatingSignals();
943
944   // default for FPE signal is defined by CSF_FPE variable, if set
945   OSD_Environment aEnv("CSF_FPE");
946   TCollection_AsciiString aEnvStr = aEnv.Value();
947   if (!aEnvStr.IsEmpty())
948   {
949     aSetFPE = (aEnvStr.Value(1) != '0');
950   }
951
952   // parse arguments
953   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
954   {
955     TCollection_AsciiString anArg(theArgVec[anArgIter]);
956     anArg.LowerCase();
957     if (anArg == "asis")
958     {
959       aMode = OSD_SignalMode_AsIs;
960     }
961     else if (anArg == "set")
962     {
963       aMode = OSD_SignalMode_Set;
964     }
965     else if (anArg == "unhandled")
966     {
967       aMode = OSD_SignalMode_SetUnhandled;
968     }
969     else if (anArg == "unset")
970     {
971       aMode = OSD_SignalMode_Unset;
972     }
973     else if (anArg == "1" || anArg == "on")
974     {
975       aSetFPE = Standard_True;
976     }
977     else if (anArg == "0" || anArg == "off")
978     {
979       aSetFPE = Standard_False;
980     }
981     else if (anArg == "default")
982     {
983     }
984     else
985     {
986       std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
987       return 1;
988     }
989   }
990
991   OSD::SetSignal(aMode, aSetFPE);
992
993   // report actual status in the end
994   const char* aModeStr = 0;
995   switch (OSD::SignalMode())
996   {
997   default:
998   case OSD_SignalMode_AsIs:         aModeStr = "asis";      break;
999   case OSD_SignalMode_Set:          aModeStr = "set";       break;
1000   case OSD_SignalMode_SetUnhandled: aModeStr = "unhandled"; break;
1001   case OSD_SignalMode_Unset:        aModeStr = "unset";     break;
1002   }
1003   theDI << "Signal mode: " << aModeStr << "\n"
1004         << "Catch FPE: " << (OSD::ToCatchFloatingSignals() ? "1" : "0") << "\n";
1005   return 0;
1006 }
1007
1008 //==============================================================================
1009 //function : dtracelevel
1010 //purpose  :
1011 //==============================================================================
1012
1013 static int dtracelevel (Draw_Interpretor& theDI,
1014                         Standard_Integer  theArgNb,
1015                         const char**      theArgVec)
1016 {
1017   Message_Gravity aLevel = Message_Info;
1018   if (theArgNb < 1 || theArgNb > 2)
1019   {
1020     std::cout << "Error: wrong number of arguments! See usage:\n";
1021     theDI.PrintHelp (theArgVec[0]);
1022     return 1;
1023   }
1024   else if (theArgNb == 2)
1025   {
1026     TCollection_AsciiString aVal (theArgVec[1]);
1027     aVal.LowerCase();
1028     if (aVal == "trace")
1029     {
1030       aLevel = Message_Trace;
1031     }
1032     else if (aVal == "info")
1033     {
1034       aLevel = Message_Info;
1035     }
1036     else if (aVal == "warn"
1037           || aVal == "warning")
1038     {
1039       aLevel = Message_Warning;
1040     }
1041     else if (aVal == "alarm")
1042     {
1043       aLevel = Message_Alarm;
1044     }
1045     else if (aVal == "fail")
1046     {
1047       aLevel = Message_Fail;
1048     }
1049     else
1050     {
1051       std::cout << "Error: unknown gravity '" << theArgVec[1] << "'!\n";
1052       return 1;
1053     }
1054   }
1055
1056   Handle(Message_Messenger) aMessenger = Message::DefaultMessenger();
1057   if (aMessenger.IsNull())
1058   {
1059     std::cout << "Error: default messenger is unavailable!\n";
1060     return 1;
1061   }
1062
1063   Message_SequenceOfPrinters& aPrinters = aMessenger->ChangePrinters();
1064   if (aPrinters.Length() < 1)
1065   {
1066     std::cout << "Error: no printers registered in default Messenger!\n";
1067     return 0;
1068   }
1069
1070   for (Standard_Integer aPrinterIter = 1; aPrinterIter <= aPrinters.Length(); ++aPrinterIter)
1071   {
1072     Handle(Message_Printer)& aPrinter = aPrinters.ChangeValue (aPrinterIter);
1073     if (theArgNb == 1)
1074     {
1075       if (aPrinterIter == 1)
1076       {
1077         aLevel = aPrinter->GetTraceLevel();
1078       }
1079       else if (aLevel == aPrinter->GetTraceLevel())
1080       {
1081         continue;
1082       }
1083
1084       switch (aPrinter->GetTraceLevel())
1085       {
1086         case Message_Trace:   theDI << "trace"; break;
1087         case Message_Info:    theDI << "info";  break;
1088         case Message_Warning: theDI << "warn";  break;
1089         case Message_Alarm:   theDI << "alarm"; break;
1090         case Message_Fail:    theDI << "fail";  break;
1091       }
1092       continue;
1093     }
1094
1095     aPrinter->SetTraceLevel (aLevel);
1096   }
1097
1098   return 0;
1099 }
1100
1101 void Draw::BasicCommands(Draw_Interpretor& theCommands)
1102 {
1103   static Standard_Boolean Done = Standard_False;
1104   if (Done) return;
1105   Done = Standard_True;
1106
1107   std::ios::sync_with_stdio();
1108
1109   const char* g = "DRAW General Commands";
1110
1111   theCommands.Add("batch", "returns 1 in batch mode",
1112                   __FILE__,ifbatch,g);
1113   theCommands.Add("spy","spy [file], Save commands in file. no file close",
1114                   __FILE__,spy,g);
1115   theCommands.Add("wait","wait [time(10)], wait time seconds",
1116                   __FILE__,Draw_wait,g);
1117   theCommands.Add("cpulimit","cpulimit [nbseconds], no args remove limits",
1118                   __FILE__,cpulimit,g);
1119   theCommands.Add("chrono","chrono [name action [action...]] \n  Operates named timer.\n"
1120                            "  Supported actions: reset, start, stop, restart, show, counter [text].\n"
1121                            "  Without arguments enables / disables global timer for all DRAW commands.",
1122                   __FILE__,chronom,g);
1123   theCommands.Add("dchrono","see help of chrono command",
1124                   __FILE__,dchronom,g);
1125   theCommands.Add("mallochook",
1126                   "debug memory allocation/deallocation, w/o args for help",
1127                   __FILE__, mallochook, g);
1128   theCommands.Add ("meminfo",
1129     "meminfo [virt|v] [heap|h] [wset|w] [wsetpeak] [swap] [swappeak] [private]"
1130     " : memory counters for this process",
1131           __FILE__, dmeminfo, g);
1132   theCommands.Add("dperf","dperf [reset] -- show performance counters, reset if argument is provided",
1133                   __FILE__,dperf,g);
1134   theCommands.Add("dsetsignal","dsetsignal [{asis|set|unhandled|unset}=set] [{0|1|default=$CSF_FPE}]\n -- set OSD signal handler, with FPE option if argument is given",
1135                   __FILE__,dsetsignal,g);
1136
1137   theCommands.Add("dparallel",
1138     "dparallel [-occt {0|1}] [-nbThreads Count] [-nbDefThreads Count]"
1139     "\n\t\t: Manages global parallelization parameters:"
1140     "\n\t\t:   -occt         use OCCT implementation or external library (if available)"
1141     "\n\t\t:   -nbThreads    specify the number of threads in default thread pool"
1142     "\n\t\t:   -nbDefThreads specify the upper limit of threads to be used for default thread pool"
1143     "\n\t\t:                 within single parallelization call (should be <= of overall number of threads),"
1144     "\n\t\t:                 so that nested algorithm can also use this pool",
1145       __FILE__,dparallel,g);
1146
1147   // Logging commands; note that their names are hard-coded in the code
1148   // of Draw_Interpretor, thus should not be changed without update of that code!
1149   theCommands.Add("dlog", "manage logging of commands and output; run without args to get help",
1150                   __FILE__,dlog,g);
1151   theCommands.Add("decho", "switch on / off echo of commands to cout; run without args to get help",
1152                   __FILE__,decho,g);
1153   theCommands.Add("dtracelevel", "dtracelevel [trace|info|warn|alarm|fail]",
1154                   __FILE__, dtracelevel, g);
1155
1156   theCommands.Add("dbreak", "raises Tcl exception if user has pressed Control-Break key",
1157                   __FILE__,dbreak,g);
1158   theCommands.Add("dversion", "provides information on OCCT build configuration (version, compiler, OS, C library, etc.)",
1159                   __FILE__,dversion,g);
1160   theCommands.Add("dlocale", "set and / or query locate of C subsystem (function setlocale())",
1161                   __FILE__,dlocale,g);
1162 }