C++ AtomicInt类代码示例

/*
    Builds the DynamicRoutingTable from Control Provider and Services
    definition tables in this file:
      - SvcsRegDefinitionTable defines OpenPegasus services to be registered
      - CtlProviderRegDefinitionTable defines Control Providers

    This is a static method.
*/
void DynamicRoutingTable::buildRoutingTable()
{
    // Lock during table build
    static AtomicInt _initialized(0);
    static Mutex _monitor;

    // Get the address of the routing table
    DynamicRoutingTable * routingTable =
        DynamicRoutingTable::getRoutingTable();

    // Assure table built only once
    if (_initialized.get() == 0)
    {
        // lock and retest
        AutoMutex autoMut(_monitor);
        if (_initialized.get() == 0)
        {
            const Uint32 NUM_SVCS = sizeof(SvcsRegDefinitionTable) /
                    sizeof(SvcsRegDefinitionTable[0]);

            // Insert a record into the table for each entry in the
            // SvcsDefinitionTable
            for (Uint32 i = 0; i < NUM_SVCS; i++)
            {
                Uint32 serviceId = MessageQueue::lookup(
                    SvcsRegDefinitionTable[i].serviceName)->getQueueId();

                routingTable->_insertRecord(
                    SvcsRegDefinitionTable[i].className,
                    SvcsRegDefinitionTable[i].namespaceName,
                    String::EMPTY,
                    serviceId);
            }

            // Add Control Providers from CtlProviderRegDefintionTable
            const Uint32 NUM_CTL_PROVIDERS =
                sizeof(CtlProviderRegDefinitionTable) /
                 sizeof(CtlProviderRegDefinitionTable[0]);

            // all Control provider routing is through controlService
            Uint32 controlServiceId = MessageQueue::lookup(
                PEGASUS_QUEUENAME_CONTROLSERVICE)->getQueueId();

            for (Uint32 i = 0; i < NUM_CTL_PROVIDERS; i++)
            {
                routingTable->_insertRecord(
                    CtlProviderRegDefinitionTable[i].className,
                    CtlProviderRegDefinitionTable[i].namespaceName,
                    CtlProviderRegDefinitionTable[i].providerName,
                    controlServiceId);
            }
            // set initialized flag
            _initialized = 1;
#ifdef PEGASUS_DEBUG
            _tableInitialized = true;
#endif
        }
    }
    //// routingTable->dumpRegTable();
}

// Test Thread and AtomicInt
void test02()
{
    const Uint32 numThreads = 64;
    AtomicInt * atom = new AtomicInt(0);
    Thread* threads[numThreads];

    (*atom)++;
    Boolean zero = atom->DecAndTestIfZero();
    assert(zero);

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i] = new Thread(atomicIncrement, atom, false);
    }

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i]->run();
    }

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i]->join();
        delete threads[i];
    }

    assert(atom->value() == numThreads);
    delete atom;
}

// Test Thread and AtomicInt
void test02()
{
    const Uint32 numThreads = 64;
    AtomicInt * atom = new AtomicInt(0);
    Thread* threads[numThreads];

    (*atom)++;
    Boolean zero = atom->decAndTestIfZero();
    PEGASUS_TEST_ASSERT(zero);

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i] = new Thread(atomicIncrement, atom, false);
    }

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i]->run();
    }

    for (Uint32 i=0; i<numThreads; i++)
    {
        threads[i]->join();
        delete threads[i];
    }

    PEGASUS_TEST_ASSERT(atom->get() == numThreads);
    delete atom;
}

ThreadReturnType PEGASUS_THREAD_CDECL funcSleepUntilCancelled(
    void* parm)
{
    AtomicInt* cancelled = static_cast<AtomicInt*>(parm);

    while (cancelled->get() == 0)
    {
        Threads::sleep(1);
    }

    return 0;
}

ThreadReturnType PEGASUS_THREAD_CDECL atomicIncrement(void * parm)
{
    Thread* my_thread  = (Thread *)parm;
    AtomicInt * atom = (AtomicInt *)my_thread->get_parm();

    (*atom)++;
    (*atom)++; (*atom)++; (*atom)++; (*atom)++;
    (*atom)--; (*atom)--;
    (*atom)--;
    Boolean zero = atom->decAndTestIfZero();
    PEGASUS_TEST_ASSERT(zero == false);

    return ThreadReturnType(0);
}

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL atomicIncrement(void * parm)
{
    Thread* my_thread  = (Thread *)parm;
    AtomicInt * atom = (AtomicInt *)my_thread->get_parm();

    (*atom)++;
    (*atom)+=4;
    (*atom)-=2;
    (*atom)--;
    Boolean zero = atom->DecAndTestIfZero();
    assert(zero == false);

    my_thread->exit_self(0);
    return 0;
}

void	AtomicIntOp::exec_both (AtomicInt <T> &atom, F &ftor, T &val_old, T &val_new)
{
	assert (&atom != 0);
	assert (&ftor != 0);

	T					val_cur;
	do
	{
		val_cur = atom;
		val_new = ftor (val_cur);
		val_old = atom.cas (val_new, val_cur);
	}
	while (val_old != val_cur);
}

static void Initialize()
{
   static AtomicInt s_initialized;
   static Mutex s_mutex;

   if ( !s_initialized )
   {
      volatile AutoLock lock( s_mutex );
      if ( s_initialized.Load() == 0 )
      {
         uint32 M, m, r, b, beta, conf, le;
         char lang[ 8 ];

         (*API->Global->GetPixInsightVersion)( &M, &m, &r, &b, &beta, &conf, &le, lang );

         s_major = int( M );
         s_minor = int( m );
         s_release = int( r );
         s_build = int( b );
         s_beta = int( beta );
         s_confidential = conf != 0;
         s_le = le != 0;
         s_language = lang;

#if ( PCL_API_Version >= 0x0126 )
         char16_type* s = (*API->Global->GetPixInsightCodename)( ModuleHandle() );
         if ( s != nullptr )
         {
            s_codename = String( s );
            if ( Module != nullptr )
               Module->Deallocate( s );
         }
#endif
         s_initialized.Store( 1 );
      }
   }
}

FAKE_MESSAGE *get_next_msg(void *key)
{
   AutoPtr<FAKE_MESSAGE> msg;

   AutoMutex autoMut(msg_mutex);
   if(requests.value() < NUMBER_MSGS)
   {
      msg.reset(PEGASUS_NEW(FAKE_MESSAGE, dq_handle) FAKE_MESSAGE(key, 0));

/*****
      check for corrupted memory 
      char *p = (char *)msg;
      p += sizeof(FAKE_MESSAGE);

      *p = 0x00;
      
      if(peg_suballocator::CheckMemory(msg))
	 abort();
******/      
      
      
      
      requests++;
   }
    
   return msg.release();  
}

void testReadWriteThreads()
{
    if (verbose)
    {
        cout << "testReadWriteThreads" << endl;
    }
    ReadWriteSem *rwSem = new ReadWriteSem();
    Thread *readers[READER_COUNT];
    Thread *writers[WRITER_COUNT];

    for(int i = 0; i < READER_COUNT; i++)
    {
       readers[i] = new Thread(reading_thread, rwSem, false);
       readers[i]->run();
    }

    for( int i = 0; i < WRITER_COUNT; i++)
    {
       writers[i] = new Thread(writing_thread, rwSem, false);
       writers[i]->run();
    }
    Threads::sleep(20000);
    die = true;

    for( int i = 0; i < 40; i++)
    {
      readers[i]->join();
       delete readers[i];
    }

    for( int i = 0; i < 10; i++)
    {
       writers[i]->join();
       delete writers[i];
    }

    delete rwSem;
    if (verbose)
    {
        cout << endl
             << "read operations: " << read_count.get() << endl
             << "write operations: " << write_count.get() << endl;
    }
}

int _beginTest(CIMClient& workClient,
               Uint32 indicationSendCount,
               Uint32 runClientThreadCount,
               const String& processIdFile,
               const String& logFile)
{

#ifdef PEGASUS_USE_NET_SNMP

    // Stop snmptrapd process if it is running
    _stopSnmptrapd(processIdFile);

    // if trapLogFile exists, remove it
    _removeTrapLogFile(logFile);

    FILE * trapInfo;

    try
    {
        _startSnmptrapd(&trapInfo, processIdFile, logFile);
    }
    catch (Exception & e)
    {
        cerr << e.getMessage() << endl;
        return (-1);
    }

    // Extended for all snmp implementation
    _receiveExpectedTraps(workClient, indicationSendCount,
                          runClientThreadCount, logFile);

    // Stop snmptrapd process if it is running and remove procIdFile
    _stopSnmptrapd(processIdFile);

    pclose(trapInfo);

    // if error encountered then fail the test.
    if (errorsEncountered.get())
    {
        cout << "+++++ test failed" << endl;
        return (-1);
    }
    else
    {
        cout << "+++++ passed all tests" << endl;
    }

    return (0);

#else
    cerr << "Cannot create a trap receiver." << endl;
    return (-1);
#endif
}

void ThreadPool::notify(int inIndex)
{
#ifdef POOL_DEBUG
	printf("ThreadPool notified for index %d\n", inIndex);
#endif
	if (mRequestCount.decrementAndTest()) {
#if defined(POOL_DEBUG) || defined(THREAD_DEBUG)
		printf("ThreadPool posting to wait semaphore\n");
#endif
		mWaitSema.post();
	}
}

ThreadReturnType PEGASUS_THREAD_CDECL _idleThd(void *parm)
{
    Thread *my_thread = (Thread *)parm;
    AutoPtr<T_Parms> parms((T_Parms *)my_thread->get_parm());
    Uint32 durationSeconds = parms->durationSeconds;
    const char * testUserid = parms->testUserid;
    const char * testPasswd = parms->testPasswd;

    CIMClient client;

    try
    {
        if (testUserid == NULL)
        {
            client.connectLocal();
        }
        else
        {
            client.connect(System::getHostName(), 5988,
                String(testUserid), String(testPasswd));
        }

        CIMClass tmpClass =
            client.getClass (OSINFO_NAMESPACE, OSINFO_CLASSNAME);

        cout << "Test 2 of 2: Begin " << durationSeconds
            << " second idle period..." << endl;

        while (sleepIterations.get() < durationSeconds)
        {
            Threads::sleep(1000);
        }
        //the client shall reconnect if the connection was closed and 
        //so the operation should succeed.
        CIMClass tmpClass2 =
            client.getClass (OSINFO_NAMESPACE, OSINFO_CLASSNAME);
    }
    catch(Exception& e)
    {
        test2CaughtException = true;
        cerr << "Error: " << e.getMessage() << endl;
    }
    client.disconnect();

    return ThreadReturnType(0);
}

//
// Tests subscription creation by sending the similar concurrent subscription
// creation requests .
//
void _testConcurrent(CIMClient &client)
{
    CIMObjectPath filterPath;
    CIMObjectPath handlerPath;
    CIMObjectPath subscriptionPath;
    try
    {
        HandlerPath = CreateHandler1Instance(client,
            PEGASUS_NAMESPACENAME_INTEROP);
        FilterPath = CreateFilterInstance(client,
            QUERY1, "WQL", "Filter1",
            PEGASUS_NAMESPACENAME_INTEROP);

        Thread thread1(createSubscriptionFunc, (void *)0, false);
        Thread thread2(createSubscriptionFunc, (void *)0, false);
        Thread thread3(createSubscriptionFunc, (void *)0, false);
        Thread thread4(createSubscriptionFunc, (void *)0, false);

        thread1.run();
        thread2.run();
        thread3.run();
        thread4.run();

        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();

        _checkSubscriptionCount(client);

        PEGASUS_TEST_ASSERT(exceptionCount.get() == 3);

        DeleteInstance(client, SubscriptionPath, PEGASUS_NAMESPACENAME_INTEROP);
        DeleteInstance(client, FilterPath, PEGASUS_NAMESPACENAME_INTEROP);
        DeleteInstance(client, HandlerPath, PEGASUS_NAMESPACENAME_INTEROP);
   }
   catch(const CIMException &e)
   {
      PEGASUS_STD(cerr) << "Exception: " << e.getMessage()
                        << PEGASUS_STD (endl);
      PEGASUS_TEST_ASSERT(0);
   }
}

// _test2 verifies that a CIM Operation on a client connection will still
// succeed when the idleConnectionTimeout period is exceeded (_idleThd) *and*
// there is concurrent server activity (_runningThd) so that the Monitor
// will wake up and check for timeouts and close the connection.
// In this case, the second call to getClass() in _idleThd() will reconnect 
// and send the request.
Boolean _test2(
    int durationSeconds, const char * testUserid, const char * testPasswd)
{
    try
    {
        sleepIterations.set(0);
        // run tests
        Array<Thread *> clientThreads;

        test2CaughtException = false;

        clientThreads.append(
            _runTestThreads(
                _runningThd, durationSeconds, testUserid, testPasswd));

        clientThreads.append(
            _runTestThreads(
                _idleThd, durationSeconds, testUserid, testPasswd));

        // wait for threads to terminate
        for(Uint32 i=0; i< clientThreads.size(); i++)
        {
            clientThreads[i]->join();
        }

        // clean up threads
        for(Uint32 i=0; i < clientThreads.size(); i++)
        {
            if(clientThreads[i])
                delete clientThreads[i];
        }
    }
    catch(Exception& e)
    {
        cerr << "Error: " << e.getMessage() << endl;
        return TEST_FAILED;
    }

    // We do not expect exception in this case.
    return (test2CaughtException == false);
}