chk_athread.cpp

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2004

   Run check files (ck_*.cpp) concurrently in threads
      
   Build: make chk_athread

   --- Internal Note --
   If building this file with WY_DEBUG defined and run, incorrect output
   will result, for internal debug statistics are not thread serialized, 
*/
#include "wy_thread.h"
#include "wy_uty.h"
#include <cstdlib>

#include <iostream>
#if WY_THREAD_VERSION!=31
#error Test code is for WY_THREAD_VERSION 31
#endif

extern void ck_str(void);
extern void ck_timespec(void);
extern void ck_date(void);
extern void ck_chrfile(bool);
extern void ck_regfile(bool,const char*);
extern void ck_dirfile(void);
extern void ck_num(void);
extern void ck_math(void);

// Run given f in thread
//
class TestThread : public Wy_Thread {
  public:
    TestThread(void (*f)(void),const char* tname)
           : Wy_Thread(),_tname(tname),_chk_func(f) {};
    ~TestThread() throw()
           {
             tmain_close();     // stop possibly active thread
           };
  protected:
   virtual WyRet tmain(void);
  private:
     const char* _tname;
     void (*_chk_func)(void);
     static const char* chdr;
};

const char* TestThread::chdr=
                  "--- TestThread::tmain(..) caught: --- ";
WyRet TestThread::tmain(void)
try {
 Wy::cout << "Entered ...  " << _tname << '\n';
 _chk_func();
 Wy::cout << "Left Ok ... ~" << _tname << '\n';
 return(Ok); 
}
catch(const WyRet& e) {
 Wy::cerr << chdr << _tname << '\n' <<
           Wy::wrd(e) << '\n';
 return(e);
}
catch(const std::exception& e) {
 Wy::cerr << chdr << _tname << '\n' <<
           "std::exception" << '\n';
 WY_RETURN( WyRet() );
}
catch(...) {
 Wy::cerr << chdr << _tname << '\n' <<
           "unknown unwind" << '\n';
 WY_RETURN( WyRet() );
};

static void ct_str(void)
{
 for(int i=0; i<100; ++i) {
   ck_str();
 }
};

static void ct_timespec(void)
{ 
 for(int i=0; i<8; ++i) {
   ck_timespec();
 }
};

static void ct_date(void)
{
 for(int i=0; i<200; ++i) {
   ck_date();
 }
};

static void ct_regfile(void)
{
 ck_regfile(false,"wytimespec.cpp");
 ck_regfile(false,"wytimespec.o");
 ck_regfile(false,"chk_timespec");
};

static void ct_chrfile(void)
{
 for(int i=0; i<400; ++i) {
   ck_chrfile(false);
 }
};

static void ct_dirfile(void)
{
 for(int i=0; i<50; ++i) {
   ck_dirfile();
   Wy::sleep(WyTimeSpec(Wy_Second(),100000000));  // 0.1 secs
 }
};

static void ct_num(void)
{
 for(int i=0; i<40; ++i) {
   ck_num();
 }
};

static void ct_math(void)
{
 for(int i=0; i<10; ++i) {
   ck_math();
 }
};

//
//
static const WyStr chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 Wy::cout << "\nChecking concurrently in threads...\n";

 WyRet r;
 TestThread tf2(ct_str,"ck_str");
 TestThread tf3(ct_date,"ck_date");
 TestThread tf4(ct_regfile,"ck_regfile");
 TestThread tf5(ct_chrfile,"ck_chrfile");
 TestThread tf6(ct_timespec,"ck_timespec");
 TestThread tf8(ct_dirfile,"ck_dirfile");
 TestThread tf9(ct_num,"ck_num");
 TestThread tf10(ct_math,"ck_math");

 // Begin threads
 if((r=tf2.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf3.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf5.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf4.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf6.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf8.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf9.begin())!=Ok) {
   WY_THROW(r);
 }
 if((r=tf10.begin())!=Ok) {
   WY_THROW(r);
 }

 // Wait stopped
 Wy::cout << '\n';
 if((r=tf2.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf3.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf5.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf4.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf6.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf8.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf9.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 if((r=tf10.wait_not(Wy_Thread::Active))!=Ok) {
   WY_THROW(r);
 };
 Wy::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 Wy::cerr << chdr << Wy::wrd(e) << '\n';
 return(-1);
}
catch(const std::exception& e) {
 Wy::cerr << chdr << "main caught(std::exception)\n";
 return(-1);
}
catch(...) {
 Wy::cerr << chdr << "main caught(...)\n";
 return(-1);
};