Made all changes related to non-blocking behaviour configurable with --enable-non-blocking=yes option
Project: http://git-wip-us.apache.org/repos/asf/logging-log4cxx/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4cxx/commit/72701c84 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4cxx/tree/72701c84 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4cxx/diff/72701c84 Branch: refs/heads/master Commit: 72701c84efd1f4a96a90bb4eec63abbbce497c69 Parents: 21f4e3d Author: Denys Smolianiuk <[email protected]> Authored: Thu Aug 23 16:26:13 2018 +0300 Committer: Denys Smolianiuk <[email protected]> Committed: Thu Aug 23 16:26:13 2018 +0300 ---------------------------------------------------------------------- configure.ac | 13 +- src/main/cpp/Makefile.am | 7 +- src/main/cpp/asyncappender.cpp | 103 +++-- src/main/cpp/asyncappender_nonblocking.cpp | 390 +++++++++++++++++++ src/main/cpp/messagebuffer.cpp | 11 +- src/main/cpp/mutex.cpp | 15 +- src/main/cpp/synchronized.cpp | 2 + src/main/include/log4cxx/asyncappender.h | 21 +- src/main/include/log4cxx/helpers/mutex.h | 13 +- src/main/include/log4cxx/helpers/synchronized.h | 9 + 10 files changed, 518 insertions(+), 66 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/configure.ac ---------------------------------------------------------------------- diff --git a/configure.ac b/configure.ac index d8ad3d4..561928c 100644 --- a/configure.ac +++ b/configure.ac @@ -64,8 +64,6 @@ case "$host" in ;; esac -CXXFLAGS="$CXXFLAGS -std=c++11" - # Doxygen AC_ARG_ENABLE(doxygen, @@ -445,6 +443,17 @@ case "$ac_with_logchar" in esac +AC_ARG_ENABLE(non-blocking, + AC_HELP_STRING(--enable-non-blocking, + [non-blocking mode (no)])) +if test "x$enable_non_blocking" = xyes; then + CXXFLAGS="$CXXFLAGS -std=c++11" + AC_DEFINE(NON_BLOCKING) + AC_DEFINE(RW_MUTEX) + AC_DEFINE(STATIC_STRINGSTREAM) +fi + +AM_CONDITIONAL([NON_BLOCKING], [test "x$enable_non_blocking" = xyes]) # Create files # ---------------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/Makefile.am ---------------------------------------------------------------------- diff --git a/src/main/cpp/Makefile.am b/src/main/cpp/Makefile.am index 8c1e007..6da89cb 100644 --- a/src/main/cpp/Makefile.am +++ b/src/main/cpp/Makefile.am @@ -23,7 +23,6 @@ liblog4cxx_la_SOURCES = \ appenderattachableimpl.cpp \ appenderskeleton.cpp \ aprinitializer.cpp \ - asyncappender.cpp \ basicconfigurator.cpp \ bufferedwriter.cpp \ bytearrayinputstream.cpp \ @@ -169,5 +168,11 @@ liblog4cxx_la_SOURCES = \ xmlsocketappender.cpp \ zipcompressaction.cpp +if NON_BLOCKING +liblog4cxx_la_SOURCES += asyncappender_nonblocking.cpp +else +liblog4cxx_la_SOURCES += asyncappender.cpp +endif + AM_CPPFLAGS += @CPPFLAGS_ODBC@ liblog4cxx_la_LDFLAGS = -version-info @LT_VERSION@ @LIBS_ODBC@ -@APR_LIBS@ http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/asyncappender.cpp ---------------------------------------------------------------------- diff --git a/src/main/cpp/asyncappender.cpp b/src/main/cpp/asyncappender.cpp index 0484136..336d609 100644 --- a/src/main/cpp/asyncappender.cpp +++ b/src/main/cpp/asyncappender.cpp @@ -44,8 +44,8 @@ IMPLEMENT_LOG4CXX_OBJECT(AsyncAppender) AsyncAppender::AsyncAppender() : AppenderSkeleton(), - buffer(DEFAULT_BUFFER_SIZE), - SHARED_MUTEX_INIT(bufferMutex, pool), + buffer(), + bufferMutex(pool), bufferNotFull(pool), bufferNotEmpty(pool), discardMap(new DiscardMap()), @@ -125,19 +125,16 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) { { - LOCK_R sync(bufferMutex); + synchronized sync(bufferMutex); while(true) { - - event->addRef(); - if (buffer.bounded_push(event)) - { - bufferNotEmpty.signalAll(); - break; - } - else - { - event->releaseRef(); - } + int previousSize = buffer.size(); + if (previousSize < bufferSize) { + buffer.push_back(event); + if (previousSize == 0) { + bufferNotEmpty.signalAll(); + } + break; + } // // Following code is only reachable if buffer is full @@ -151,7 +148,7 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) { && !Thread::interrupted() && !dispatcher.isCurrentThread()) { try { - bufferNotFull.await(); + bufferNotFull.await(bufferMutex); discard = false; } catch (InterruptedException& e) { // @@ -167,7 +164,14 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) { // add event to discard map. // if (discard) { - discardedCount++; + LogString loggerName = event->getLoggerName(); + DiscardMap::iterator iter = discardMap->find(loggerName); + if (iter == discardMap->end()) { + DiscardSummary summary(event); + discardMap->insert(DiscardMap::value_type(loggerName, summary)); + } else { + (*iter).second.add(event); + } break; } } @@ -181,13 +185,12 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) { void AsyncAppender::close() { { - LOCK_W sync(bufferMutex); + synchronized sync(bufferMutex); closed = true; + bufferNotEmpty.signalAll(); + bufferNotFull.signalAll(); } - bufferNotEmpty.signalAll(); - bufferNotFull.signalAll(); - #if APR_HAS_THREADS try { dispatcher.join(); @@ -262,12 +265,8 @@ void AsyncAppender::setBufferSize(int size) if (size < 0) { throw IllegalArgumentException(LOG4CXX_STR("size argument must be non-negative")); } - - { - LOCK_W sync(bufferMutex); - bufferSize = (size < 1) ? 1 : size; - buffer.reserve_unsafe(bufferSize); - } + synchronized sync(bufferMutex); + bufferSize = (size < 1) ? 1 : size; bufferNotFull.signalAll(); } @@ -277,10 +276,8 @@ int AsyncAppender::getBufferSize() const } void AsyncAppender::setBlocking(bool value) { - { - LOCK_W sync(bufferMutex); - blocking = value; - } + synchronized sync(bufferMutex); + blocking = value; bufferNotFull.signalAll(); } @@ -323,7 +320,7 @@ LoggingEventPtr AsyncAppender::DiscardSummary::createEvent(Pool& p) { ::log4cxx::spi::LoggingEventPtr AsyncAppender::DiscardSummary::createEvent(::log4cxx::helpers::Pool& p, - unsigned discardedCount) + size_t discardedCount) { LogString msg(LOG4CXX_STR("Discarded ")); StringHelper::toString(discardedCount, p, msg); @@ -339,39 +336,37 @@ AsyncAppender::DiscardSummary::createEvent(::log4cxx::helpers::Pool& p, #if APR_HAS_THREADS void* LOG4CXX_THREAD_FUNC AsyncAppender::dispatch(apr_thread_t* /*thread*/, void* data) { AsyncAppender* pThis = (AsyncAppender*) data; + bool isActive = true; try { - while (!pThis->closed) { - - pThis->bufferNotEmpty.await(); - + while (isActive) { // // process events after lock on buffer is released. // Pool p; LoggingEventList events; { - LOCK_R sync(pThis->bufferMutex); - - unsigned count = 0; - log4cxx::spi::LoggingEvent * logPtr = nullptr; - while (pThis->buffer.pop(logPtr)) - { - log4cxx::spi::LoggingEventPtr ptr(logPtr); - events.push_back(ptr); - logPtr->releaseRef(); - count++; + synchronized sync(pThis->bufferMutex); + size_t bufferSize = pThis->buffer.size(); + isActive = !pThis->closed; + + while((bufferSize == 0) && isActive) { + pThis->bufferNotEmpty.await(pThis->bufferMutex); + bufferSize = pThis->buffer.size(); + isActive = !pThis->closed; } - - if (pThis->blocking) { - pThis->bufferNotFull.signalAll(); + for(LoggingEventList::iterator eventIter = pThis->buffer.begin(); + eventIter != pThis->buffer.end(); + eventIter++) { + events.push_back(*eventIter); } - - unsigned discarded = pThis->discardedCount.exchange(0); - - if (discarded != 0) - { - events.push_back(AsyncAppender::DiscardSummary::createEvent(p, discarded)); + for(DiscardMap::iterator discardIter = pThis->discardMap->begin(); + discardIter != pThis->discardMap->end(); + discardIter++) { + events.push_back(discardIter->second.createEvent(p)); } + pThis->buffer.clear(); + pThis->discardMap->clear(); + pThis->bufferNotFull.signalAll(); } for (LoggingEventList::iterator iter = events.begin(); http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/asyncappender_nonblocking.cpp ---------------------------------------------------------------------- diff --git a/src/main/cpp/asyncappender_nonblocking.cpp b/src/main/cpp/asyncappender_nonblocking.cpp new file mode 100644 index 0000000..b6cedfa --- /dev/null +++ b/src/main/cpp/asyncappender_nonblocking.cpp @@ -0,0 +1,390 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if defined(_MSC_VER) +#pragma warning ( disable: 4231 4251 4275 4786 ) +#endif + +#include <log4cxx/asyncappender.h> + + +#include <log4cxx/helpers/loglog.h> +#include <log4cxx/spi/loggingevent.h> +#include <apr_thread_proc.h> +#include <apr_thread_mutex.h> +#include <apr_thread_cond.h> +#include <log4cxx/helpers/condition.h> +#include <log4cxx/helpers/synchronized.h> +#include <log4cxx/helpers/stringhelper.h> +#include <apr_atomic.h> +#include <log4cxx/helpers/optionconverter.h> + + +using namespace log4cxx; +using namespace log4cxx::helpers; +using namespace log4cxx::spi; + + +IMPLEMENT_LOG4CXX_OBJECT(AsyncAppender) + + +AsyncAppender::AsyncAppender() +: AppenderSkeleton(), + buffer(DEFAULT_BUFFER_SIZE), + SHARED_MUTEX_INIT(bufferMutex, pool), + bufferNotFull(pool), + bufferNotEmpty(pool), + discardMap(new DiscardMap()), + bufferSize(DEFAULT_BUFFER_SIZE), + appenders(new AppenderAttachableImpl(pool)), + dispatcher(), + locationInfo(false), + blocking(true) { +#if APR_HAS_THREADS + dispatcher.run(dispatch, this); +#endif +} + +AsyncAppender::~AsyncAppender() +{ + finalize(); + delete discardMap; +} + +void AsyncAppender::addRef() const { + ObjectImpl::addRef(); +} + +void AsyncAppender::releaseRef() const { + ObjectImpl::releaseRef(); +} + +void AsyncAppender::addAppender(const AppenderPtr& newAppender) +{ + synchronized sync(appenders->getMutex()); + appenders->addAppender(newAppender); +} + + +void AsyncAppender::setOption(const LogString& option, + const LogString& value) { + if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("LOCATIONINFO"), LOG4CXX_STR("locationinfo"))) { + setLocationInfo(OptionConverter::toBoolean(value, false)); + } + if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFERSIZE"), LOG4CXX_STR("buffersize"))) { + setBufferSize(OptionConverter::toInt(value, DEFAULT_BUFFER_SIZE)); + } + if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BLOCKING"), LOG4CXX_STR("blocking"))) { + setBlocking(OptionConverter::toBoolean(value, true)); + } else { + AppenderSkeleton::setOption(option, value); + } +} + + +void AsyncAppender::doAppend(const spi::LoggingEventPtr& event, Pool& pool1) +{ + LOCK_R sync(mutex); + + doAppendImpl(event, pool1); +} + +void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) { +#if APR_HAS_THREADS + // + // if dispatcher has died then + // append subsequent events synchronously + // + if (!dispatcher.isAlive() || bufferSize <= 0) { + synchronized sync(appenders->getMutex()); + appenders->appendLoopOnAppenders(event, p); + return; + } + + // Set the NDC and thread name for the calling thread as these + // LoggingEvent fields were not set at event creation time. + LogString ndcVal; + event->getNDC(ndcVal); + event->getThreadName(); + // Get a copy of this thread's MDC. + event->getMDCCopy(); + + + { + LOCK_R sync(bufferMutex); + while(true) { + + event->addRef(); + if (buffer.bounded_push(event)) + { + bufferNotEmpty.signalAll(); + break; + } + else + { + event->releaseRef(); + } + + // + // Following code is only reachable if buffer is full + // + // + // if blocking and thread is not already interrupted + // and not the dispatcher then + // wait for a buffer notification + bool discard = true; + if (blocking + && !Thread::interrupted() + && !dispatcher.isCurrentThread()) { + try { + bufferNotFull.await(); + discard = false; + } catch (InterruptedException& e) { + // + // reset interrupt status so + // calling code can see interrupt on + // their next wait or sleep. + Thread::currentThreadInterrupt(); + } + } + + // + // if blocking is false or thread has been interrupted + // add event to discard map. + // + if (discard) { + discardedCount++; + break; + } + } + } +#else + synchronized sync(appenders->getMutex()); + appenders->appendLoopOnAppenders(event, p); +#endif + } + + +void AsyncAppender::close() { + { + LOCK_W sync(bufferMutex); + closed = true; + } + + bufferNotEmpty.signalAll(); + bufferNotFull.signalAll(); + +#if APR_HAS_THREADS + try { + dispatcher.join(); + } catch(InterruptedException& e) { + Thread::currentThreadInterrupt(); + LogLog::error(LOG4CXX_STR("Got an InterruptedException while waiting for the dispatcher to finish,"), e); + } +#endif + + { + synchronized sync(appenders->getMutex()); + AppenderList appenderList = appenders->getAllAppenders(); + for (AppenderList::iterator iter = appenderList.begin(); + iter != appenderList.end(); + iter++) { + (*iter)->close(); + } + } +} + +AppenderList AsyncAppender::getAllAppenders() const +{ + synchronized sync(appenders->getMutex()); + return appenders->getAllAppenders(); +} + +AppenderPtr AsyncAppender::getAppender(const LogString& n) const +{ + synchronized sync(appenders->getMutex()); + return appenders->getAppender(n); +} + +bool AsyncAppender::isAttached(const AppenderPtr& appender) const +{ + synchronized sync(appenders->getMutex()); + return appenders->isAttached(appender); +} + +bool AsyncAppender::requiresLayout() const { + return false; +} + +void AsyncAppender::removeAllAppenders() +{ + synchronized sync(appenders->getMutex()); + appenders->removeAllAppenders(); +} + +void AsyncAppender::removeAppender(const AppenderPtr& appender) +{ + synchronized sync(appenders->getMutex()); + appenders->removeAppender(appender); +} + +void AsyncAppender::removeAppender(const LogString& n) +{ + synchronized sync(appenders->getMutex()); + appenders->removeAppender(n); +} + +bool AsyncAppender::getLocationInfo() const { + return locationInfo; +} + +void AsyncAppender::setLocationInfo(bool flag) { + locationInfo = flag; +} + + +void AsyncAppender::setBufferSize(int size) +{ + if (size < 0) { + throw IllegalArgumentException(LOG4CXX_STR("size argument must be non-negative")); + } + + { + LOCK_W sync(bufferMutex); + bufferSize = (size < 1) ? 1 : size; + buffer.reserve_unsafe(bufferSize); + } + bufferNotFull.signalAll(); +} + +int AsyncAppender::getBufferSize() const +{ + return bufferSize; +} + +void AsyncAppender::setBlocking(bool value) { + { + LOCK_W sync(bufferMutex); + blocking = value; + } + bufferNotFull.signalAll(); +} + +bool AsyncAppender::getBlocking() const { + return blocking; +} + +AsyncAppender::DiscardSummary::DiscardSummary(const LoggingEventPtr& event) : + maxEvent(event), count(1) { +} + +AsyncAppender::DiscardSummary::DiscardSummary(const DiscardSummary& src) : + maxEvent(src.maxEvent), count(src.count) { +} + +AsyncAppender::DiscardSummary& AsyncAppender::DiscardSummary::operator=(const DiscardSummary& src) { + maxEvent = src.maxEvent; + count = src.count; + return *this; +} + +void AsyncAppender::DiscardSummary::add(const LoggingEventPtr& event) { + if (event->getLevel()->toInt() > maxEvent->getLevel()->toInt()) { + maxEvent = event; + } + count++; +} + +LoggingEventPtr AsyncAppender::DiscardSummary::createEvent(Pool& p) { + LogString msg(LOG4CXX_STR("Discarded ")); + StringHelper::toString(count, p, msg); + msg.append(LOG4CXX_STR(" messages due to a full event buffer including: ")); + msg.append(maxEvent->getMessage()); + return new LoggingEvent( + maxEvent->getLoggerName(), + maxEvent->getLevel(), + msg, + LocationInfo::getLocationUnavailable()); +} + +::log4cxx::spi::LoggingEventPtr +AsyncAppender::DiscardSummary::createEvent(::log4cxx::helpers::Pool& p, + size_t discardedCount) +{ + LogString msg(LOG4CXX_STR("Discarded ")); + StringHelper::toString(discardedCount, p, msg); + msg.append(LOG4CXX_STR(" messages due to a full event buffer")); + + return new LoggingEvent( + LOG4CXX_STR(""), + log4cxx::Level::getError(), + msg, + LocationInfo::getLocationUnavailable()); +} + +#if APR_HAS_THREADS +void* LOG4CXX_THREAD_FUNC AsyncAppender::dispatch(apr_thread_t* /*thread*/, void* data) { + AsyncAppender* pThis = (AsyncAppender*) data; + try { + while (!pThis->closed) { + + pThis->bufferNotEmpty.await(); + + // + // process events after lock on buffer is released. + // + Pool p; + LoggingEventList events; + { + LOCK_R sync(pThis->bufferMutex); + + unsigned count = 0; + log4cxx::spi::LoggingEvent * logPtr = nullptr; + while (pThis->buffer.pop(logPtr)) + { + log4cxx::spi::LoggingEventPtr ptr(logPtr); + events.push_back(ptr); + logPtr->releaseRef(); + count++; + } + + if (pThis->blocking) { + pThis->bufferNotFull.signalAll(); + } + + size_t discarded = pThis->discardedCount.exchange(0); + + if (discarded != 0) + { + events.push_back(AsyncAppender::DiscardSummary::createEvent(p, discarded)); + } + } + + for (LoggingEventList::iterator iter = events.begin(); + iter != events.end(); + iter++) { + synchronized sync(pThis->appenders->getMutex()); + pThis->appenders->appendLoopOnAppenders(*iter, p); + } + } + } catch(InterruptedException& ex) { + Thread::currentThreadInterrupt(); + } catch(...) { + } + return 0; +} +#endif http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/messagebuffer.cpp ---------------------------------------------------------------------- diff --git a/src/main/cpp/messagebuffer.cpp b/src/main/cpp/messagebuffer.cpp index 39a5f2a..e13d312 100644 --- a/src/main/cpp/messagebuffer.cpp +++ b/src/main/cpp/messagebuffer.cpp @@ -40,7 +40,9 @@ void ResetStream(std::basic_ostringstream<T> &stream) } CharMessageBuffer::CharMessageBuffer() : stream(0) { - if (gMessageBufferUseStaticStream) + +#if defined(STATIC_STRINGSTREAM) +if (gMessageBufferUseStaticStream) { thread_local static char ossBuf[8192]; thread_local static std::basic_ostringstream<char> sStream; @@ -54,6 +56,7 @@ CharMessageBuffer::CharMessageBuffer() : stream(0) { } stream = &sStream; } +#endif } CharMessageBuffer::~CharMessageBuffer() { @@ -143,6 +146,8 @@ std::ostream& CharMessageBuffer::operator<<(void* val) { return ((std::ostream&) #if LOG4CXX_WCHAR_T_API WideMessageBuffer::WideMessageBuffer() : stream(0) { + +#if defined(STATIC_STRINGSTREAM) if (gMessageBufferUseStaticStream) { thread_local static wchar_t ossBuf[8192]; @@ -157,6 +162,7 @@ WideMessageBuffer::WideMessageBuffer() : stream(0) { } stream = &sStream; } +#endif } WideMessageBuffer::~WideMessageBuffer() { @@ -372,6 +378,8 @@ const std::basic_string<log4cxx::UniChar>& MessageBuffer::str(std::basic_ostream UniCharMessageBuffer::UniCharMessageBuffer() : stream(0) { + +#if defined(STATIC_STRINGSTREAM) if (gMessageBufferUseStaticStream) { thread_local static log4cxx::UniChar ossBuf[8192]; @@ -386,6 +394,7 @@ UniCharMessageBuffer::UniCharMessageBuffer() : stream(0) { } stream = &sStream; } +#endif } UniCharMessageBuffer::~UniCharMessageBuffer() { http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/mutex.cpp ---------------------------------------------------------------------- diff --git a/src/main/cpp/mutex.cpp b/src/main/cpp/mutex.cpp index b57595d..d76afca 100755 --- a/src/main/cpp/mutex.cpp +++ b/src/main/cpp/mutex.cpp @@ -27,6 +27,8 @@ #endif #include <log4cxx/helpers/aprinitializer.h> +#if defined(NON_BLOCKING) + #if defined(WIN32) || defined(_WIN32) || defined(_WIN64) #include <windows.h> #else @@ -34,6 +36,8 @@ #include <semaphore.h> #endif +#endif // NON_BLOCKING + using namespace log4cxx::helpers; using namespace log4cxx; @@ -75,6 +79,8 @@ apr_thread_mutex_t* Mutex::getAPRMutex() const { return mutex; } +#if defined(RW_MUTEX) + RWMutex::RWMutex(Pool& p) : id((apr_os_thread_t)-1) , count(0) @@ -152,6 +158,9 @@ void RWMutex::wrUnlock() const #endif } +#endif // RW_MUTEX + +#if defined(NON_BLOCKING) #if defined(WIN32) || defined(_WIN32) || defined(_WIN64) @@ -164,7 +173,7 @@ namespace log4cxx { } } -static const LONG cMax = 10; +static const LONG cMax = 10000; // arbitrary high value Semaphore::Semaphore(log4cxx::helpers::Pool& p) : impl(nullptr) @@ -275,4 +284,6 @@ void Semaphore::signalAll() const #endif } -#endif +#endif // POSIX + +#endif // NON_BLOCKING http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/cpp/synchronized.cpp ---------------------------------------------------------------------- diff --git a/src/main/cpp/synchronized.cpp b/src/main/cpp/synchronized.cpp index e561f54..a732c7f 100644 --- a/src/main/cpp/synchronized.cpp +++ b/src/main/cpp/synchronized.cpp @@ -60,6 +60,7 @@ synchronized::~synchronized() #endif } +#if defined(RW_MUTEX) synchronized_read::synchronized_read(const RWMutex& mutex1) : mutex(mutex1) @@ -83,3 +84,4 @@ synchronized_write::~synchronized_write() mutex.wrUnlock(); } +#endif // RW_MUTEX http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/include/log4cxx/asyncappender.h ---------------------------------------------------------------------- diff --git a/src/main/include/log4cxx/asyncappender.h b/src/main/include/log4cxx/asyncappender.h index 7d43d81..499b435 100644 --- a/src/main/include/log4cxx/asyncappender.h +++ b/src/main/include/log4cxx/asyncappender.h @@ -32,7 +32,9 @@ #include <log4cxx/helpers/mutex.h> #include <log4cxx/helpers/condition.h> +#if defined(NON_BLOCKING) #include <boost/lockfree/queue.hpp> +#endif namespace log4cxx { @@ -199,16 +201,25 @@ namespace log4cxx /** * Event buffer. */ +#if defined(NON_BLOCKING) boost::lockfree::queue<log4cxx::spi::LoggingEvent* > buffer; - std::atomic<unsigned> discardedCount; + std::atomic<size_t> discardedCount; +#else + LoggingEventList buffer; +#endif /** * Mutex used to guard access to buffer and discardMap. */ SHARED_MUTEX bufferMutex; - SEMAPHORE bufferNotFull; - SEMAPHORE bufferNotEmpty; - + +#if defined(NON_BLOCKING) + ::log4cxx::helpers::Semaphore bufferNotFull; + ::log4cxx::helpers::Semaphore bufferNotEmpty; +#else + ::log4cxx::helpers::Condition bufferNotFull; + ::log4cxx::helpers::Condition bufferNotEmpty; +#endif class DiscardSummary { private: /** @@ -249,7 +260,7 @@ namespace log4cxx static ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p, - unsigned discardedCount); + size_t discardedCount); }; /** http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/include/log4cxx/helpers/mutex.h ---------------------------------------------------------------------- diff --git a/src/main/include/log4cxx/helpers/mutex.h b/src/main/include/log4cxx/helpers/mutex.h index ea8b18e..aecc6bd 100644 --- a/src/main/include/log4cxx/helpers/mutex.h +++ b/src/main/include/log4cxx/helpers/mutex.h @@ -54,6 +54,8 @@ namespace log4cxx } // namespace log4cxx +#if defined(RW_MUTEX) + namespace log4cxx { namespace helpers @@ -84,8 +86,17 @@ namespace log4cxx } // namespace log4cxx #define SHARED_MUTEX log4cxx::helpers::RWMutex + +#else // no RW_MUTEX + +#define SHARED_MUTEX log4cxx::helpers::Mutex + +#endif // RW_MUTEX + #define SHARED_MUTEX_INIT(mutex, p) mutex(p) +#if defined(NON_BLOCKING) + namespace log4cxx { namespace helpers @@ -110,6 +121,6 @@ namespace log4cxx } // namespace helpers } // namespace log4cxx -#define SEMAPHORE log4cxx::helpers::Semaphore +#endif // NON_BLOCKING #endif //_LOG4CXX_HELPERS_MUTEX_H http://git-wip-us.apache.org/repos/asf/logging-log4cxx/blob/72701c84/src/main/include/log4cxx/helpers/synchronized.h ---------------------------------------------------------------------- diff --git a/src/main/include/log4cxx/helpers/synchronized.h b/src/main/include/log4cxx/helpers/synchronized.h index e4df183..741b24e 100644 --- a/src/main/include/log4cxx/helpers/synchronized.h +++ b/src/main/include/log4cxx/helpers/synchronized.h @@ -46,6 +46,8 @@ namespace log4cxx } } +#if defined(RW_MUTEX) + namespace log4cxx { namespace helpers { @@ -93,4 +95,11 @@ namespace log4cxx #define LOCK_R synchronized_read #define LOCK_W synchronized_write +#else + +#define LOCK_R synchronized +#define LOCK_W synchronized + +#endif // RW_MUTEX + #endif //_LOG4CXX_HELPERS_SYNCHRONIZED_H
