/************************************************************************************************

 NC_ALLOC.CPP

 * Portions Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 *

 * Copyright (c) 1997

 * Mark of the Unicorn, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Mark of the Unicorn makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

************************************************************************************************/

#include "nc_alloc.h"

#include <string>

#if defined (EH_NEW_HEADERS)

#  include <new>

#  include <cassert>

#  include <cstdlib>

#else

#  include <assert.h>

#  include <stdlib.h>

#  include <new.h>

#endif

#if defined (EH_NEW_IOSTREAMS)

#  include <iostream>

#else

#  include <iostream.h>

#endif

long alloc_count = 0;

long object_count = 0;

long TestController::possible_failure_count = 0;

const char* TestController::current_test = "<unknown>";

const char* TestController::current_test_category = "no category";

const char* TestController::current_container = 0;

bool  TestController::nc_verbose = true;

bool  TestController::never_fail = false;

bool  TestController::track_allocations = false;

bool  TestController::leak_detection_enabled = false;

TestController gTestController;

//************************************************************************************************

void TestController::maybe_fail(long) {

  if (never_fail || Failure_threshold() == kNotInExceptionTest)

    return;

  // throw if allocation would satisfy the threshold

  if (possible_failure_count++ >= Failure_threshold()) {

    // what about doing some standard new_handler() behavior here (to test it!) ???

    // reset and simulate an out-of-memory failure

    Failure_threshold() = kNotInExceptionTest;

#ifndef EH_NO_EXCEPTIONS

    throw EH_STD::bad_alloc();

#endif

  }

}

#if defined (EH_HASHED_CONTAINERS_IMPLEMENTED)

#  if defined (__SGI_STL)

#    if defined (EH_NEW_HEADERS)

#      include <hash_set>

#    else

#      include <hash_set.h>

#    endif

#  elif defined (__MSL__)

#    include <hashset.h>

#  else

#    error what do I include to get hash_set?

#  endif

#else

#  if defined (EH_NEW_HEADERS)

#    include <set>

#  else

#    include <set.h>

#  endif

#endif

#if !defined (EH_HASHED_CONTAINERS_IMPLEMENTED)

typedef EH_STD::set<void*, EH_STD::less<void*> > allocation_set;

#else

USING_CSTD_NAME(size_t)

struct hash_void {

  size_t operator()(void* x) const { return (size_t)x; }

};

typedef EH_STD::hash_set<void*, ::hash_void, EH_STD::equal_to<void*> > allocation_set;

#endif

static allocation_set& alloc_set() {

  static allocation_set s;

  return s;

}

// Prevents infinite recursion during allocation

static bool using_alloc_set = false;

#if !defined (NO_FAST_ALLOCATOR)

//

//  FastAllocator -- speeds up construction of TestClass objects when

// TESTCLASS_DEEP_DATA is enabled, and speeds up tracking of allocations

// when the suite is run with the -t option.

//

class FastAllocator {

public:

  //FastAllocator() : mFree(0), mUsed(0) {}

  static void *Allocate(size_t s) {

    void *result = 0;

    if (s <= sizeof(Block)) {

      if (mFree != 0) {

        result = mFree;

        mFree = mFree->next;

      }

      else if (mBlocks != 0 && mUsed < kBlockCount) {

        result =  (void*)&mBlocks[mUsed++];

      }

    }

    return result;

  }

  static bool Free(void* p) {

    Block* b = (Block*)p;

    if (mBlocks == 0 || b < mBlocks || b >= mBlocks + kBlockCount)

      return false;

    b->next = mFree;

    mFree = b;

    return true;

  }

  struct Block;

  friend struct Block;

  enum {

    // Number of fast allocation blocks to create.

    kBlockCount = 1500,

    // You may need to adjust this number for your platform.

    // A good choice will speed tests. A bad choice will still work.

    kMinBlockSize = 48

  };

  struct Block {

    union {

      Block *next;

      double dummy; // fbp - force alignment

      char dummy2[kMinBlockSize];

    };

  };

  static Block* mBlocks;

  static Block *mFree;

  static size_t mUsed;

};

FastAllocator::Block *FastAllocator::mBlocks =

(FastAllocator::Block*)EH_CSTD::calloc( sizeof(FastAllocator::Block), FastAllocator::kBlockCount );

FastAllocator::Block *FastAllocator::mFree;

size_t FastAllocator::mUsed;

static FastAllocator gFastAllocator;

#endif

inline char* AllocateBlock(size_t s) {

#if !defined (NO_FAST_ALLOCATOR)

  char * const p = (char*)gFastAllocator.Allocate( s );

  if (p != 0)

    return p;

#endif

  return (char*)EH_CSTD::malloc(s);

}

static void* OperatorNew( size_t s ) {

  if (!using_alloc_set) {

    simulate_possible_failure();

    ++alloc_count;

  }

  char *p = AllocateBlock(s);

  if (gTestController.TrackingEnabled() &&

      gTestController.LeakDetectionEnabled() &&

      !using_alloc_set) {

    using_alloc_set = true;

    bool inserted = alloc_set().insert(p).second;

    EH_ASSERT(inserted);

    using_alloc_set = false;

  }

  return p;

}

#if 0 //sandeep

void* _STLP_CALL operator new(size_t s)

#ifdef EH_DELETE_HAS_THROW_SPEC

throw(EH_STD::bad_alloc)

#endif

{ return OperatorNew( s ); }

#ifdef EH_USE_NOTHROW

void* _STLP_CALL operator new(size_t size, const EH_STD::nothrow_t&) throw() {

  try {

    return OperatorNew( size );

  }

  catch (...) {

    return 0;

  }

}

#endif

#if defined (EH_VECTOR_OPERATOR_NEW)

void* _STLP_CALL operator new[](size_t size ) throw(EH_STD::bad_alloc) {

  return OperatorNew( size );

}

#  ifdef EH_USE_NOTHROW

void* _STLP_CALL operator new[](size_t size, const EH_STD::nothrow_t&) throw() {

  try {

    return OperatorNew(size);

  }

  catch (...) {

    return 0;

  }

}

#  endif

void _STLP_CALL operator delete[](void* ptr) throw()

{ operator delete( ptr ); }

#endif

#if defined (EH_DELETE_HAS_THROW_SPEC)

void _STLP_CALL operator delete(void* s) throw()

#else

void _STLP_CALL operator delete(void* s)

#endif

{

  if ( s != 0 ) {

    if ( !using_alloc_set ) {

      --alloc_count;

      if ( gTestController.TrackingEnabled() && gTestController.LeakDetectionEnabled() ) {

        using_alloc_set = true;

        allocation_set::iterator p = alloc_set().find( (char*)s );

        EH_ASSERT( p != alloc_set().end() );

        alloc_set().erase( p );

        using_alloc_set = false;

      }

    }

# if ! defined (NO_FAST_ALLOCATOR)

    if ( !gFastAllocator.Free( s ) )

# endif

      EH_CSTD::free(s);

  }

}

#endif //sandeep

/*===================================================================================

  ClearAllocationSet  (private helper)

  EFFECTS:  Empty the set of allocated blocks.

====================================================================================*/

void TestController::ClearAllocationSet() {

  if (!using_alloc_set) {

    using_alloc_set = true;

    alloc_set().clear();

    using_alloc_set = false;

  }

}

bool TestController::ReportLeaked() {

  EndLeakDetection();

  if (using_alloc_set)

    EH_ASSERT( alloc_count == static_cast<int>(alloc_set().size()) );

  if (alloc_count != 0 || object_count != 0) {

    EH_STD::cerr<<"\nEH TEST FAILURE !\n";

    PrintTestName(true);

    if (alloc_count)

      EH_STD::cerr << "ERROR : " << alloc_count << " outstanding allocations.\n";

    if (object_count)

      EH_STD::cerr << "ERROR : " << object_count << " non-destroyed objects.\n";

    alloc_count = object_count = 0;

    return true;

  }

  return false;

}

/*===================================================================================

  PrintTestName

  EFFECTS: Prints information about the current test. If err is false, ends with

    an ellipsis, because the test is ongoing. If err is true an error is being

    reported, and the output ends with an endl.

====================================================================================*/

void TestController::PrintTestName(bool err) {

  if (current_container)

    EH_STD::cerr<<"["<<current_container<<"] :";

  EH_STD::cerr<<"testing "<<current_test <<" (" << current_test_category <<")";

  if (err)

    EH_STD::cerr<<EH_STD::endl;

  else

    EH_STD::cerr<<" ... ";

}

void TestController::ReportSuccess(int count) {

  if (nc_verbose)

    EH_STD::cerr<<(count+1)<<" try successful"<<EH_STD::endl;

}

long& TestController::Failure_threshold() {

  static long failure_threshold = kNotInExceptionTest;

  return failure_threshold;

}

#if 0 // enable non inline functions

void TestController::TrackAllocations(bool track) {

  track_allocations = track;

}

bool TestController::TrackingEnabled() {

  return track_allocations;

}

 void TestController::SetFailureCountdown(long count) {

  Failure_threshold() = count;

  possible_failure_count = 0;

}

void TestController::CancelFailureCountdown() {

  Failure_threshold() = kNotInExceptionTest;

}

void TestController::BeginLeakDetection() {

  alloc_count = 0;

  object_count = 0;

  ClearAllocationSet();

  leak_detection_enabled = true;

}

bool TestController::LeakDetectionEnabled() {

  return leak_detection_enabled;

}

void TestController::EndLeakDetection() {

  leak_detection_enabled = false;

}

void TestController::SetCurrentTestCategory(const char* str) {

  current_test_category = str;

  if (nc_verbose)

    PrintTestName();

}

void TestController::SetCurrentContainer(const char* str) {

  current_container=str;

}

void TestController::SetCurrentTestName(const char* str) {

  current_test = str;

}

void TestController::SetVerbose(bool val) {

  nc_verbose = val;

}

void TestController::TurnOffExceptions() {

  never_fail = true;

}

#endif