//  testonce.cpp
//
//  (C) Copyright 2005 Anthony Williams 
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include "once.hpp"
#include <assert.h>
#include <process.h>
#include <time.h>
#include <iostream>

unsigned counter=0;

void increment_counter()
{
    ++counter;
}

void test_once()
{
    boost::once_flag flag=BOOST_ONCE_INIT;
    counter=0;
    unsigned const loop_count=1000000;
    for(unsigned i=0;i<loop_count;++i)
    {
        boost::call_once(increment_counter,flag);
    }

    assert(counter==1);
}

unsigned __stdcall thread_function(void* thread_counter)
{
    static boost::once_flag once=BOOST_ONCE_INIT;
    boost::call_once(increment_counter,once);

    InterlockedIncrement(static_cast<LONG*>(thread_counter));
    
    return 0;
}


void test_once_multiple_threads()
{
    unsigned const number_of_threads=20;
    counter=0;

    HANDLE handles[number_of_threads]={0};
    unsigned thread_count=0;
    
    for(unsigned i=0;i<number_of_threads;++i)
    {
        handles[i]=(HANDLE)_beginthreadex(NULL,0,thread_function,&thread_count,0,NULL);
    }
    
    for(unsigned i=0;i<number_of_threads;++i)
    {
        ::WaitForSingleObject(handles[i],INFINITE);
        ::CloseHandle(handles[i]);
    }
    assert(counter==1);
    assert(thread_count==number_of_threads);
}

int main()
{
    time_t start=time(NULL);
    
    test_once();
    time_t end=time(NULL);
    std::cout<<"Elapsed time="<<(end-start)<<std::endl;
    
    test_once_multiple_threads();
}