From ec688b4723a041044226358bcd4dd6e2da39da49 Mon Sep 17 00:00:00 2001 From: Luca Muscariello Date: Thu, 23 Feb 2017 17:01:02 +0100 Subject: Initial commit: cframework. Longbow and Libparc Change-Id: I90378dbd30da6033b20fb1f829b3b822cf366c59 Signed-off-by: Luca Muscariello --- libparc/parc/memory/parc_BufferPool.c | 236 +++++++++++++++ libparc/parc/memory/parc_BufferPool.h | 344 ++++++++++++++++++++++ libparc/parc/memory/test/CMakeLists.txt | 13 + libparc/parc/memory/test/test_parc_BufferPool.c | 370 ++++++++++++++++++++++++ 4 files changed, 963 insertions(+) create mode 100644 libparc/parc/memory/parc_BufferPool.c create mode 100644 libparc/parc/memory/parc_BufferPool.h create mode 100644 libparc/parc/memory/test/CMakeLists.txt create mode 100644 libparc/parc/memory/test/test_parc_BufferPool.c (limited to 'libparc/parc/memory') diff --git a/libparc/parc/memory/parc_BufferPool.c b/libparc/parc/memory/parc_BufferPool.c new file mode 100644 index 00000000..d6695fdf --- /dev/null +++ b/libparc/parc/memory/parc_BufferPool.c @@ -0,0 +1,236 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed 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. + */ + +/** + */ +#include + +#include +#include +#include + +#include + +#include "parc_BufferPool.h" + +struct PARCBufferPool { + size_t bufferSize; + size_t limit; + size_t largestPoolSize; + size_t totalInstances; + size_t cacheHits; + PARCLinkedList *freeList; + PARCObjectDescriptor *descriptor; + const PARCObjectDescriptor *originalDescriptor; +}; + +static bool +_parcBufferPool_Destructor(PARCBufferPool **instancePtr) +{ + assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCBufferPool pointer."); + + PARCBufferPool *pool = *instancePtr; + + parcLinkedList_Apply(pool->freeList, (void (*))parcObject_SetDescriptor, (const void *) &PARCBuffer_Descriptor); + + parcLinkedList_Release(&pool->freeList); + parcObjectDescriptor_Destroy(&pool->descriptor); + + return true; +} + +static bool +_parcBufferPool_ObjectDestructor(PARCBuffer **bufferPtr) +{ + PARCBuffer *buffer = *bufferPtr; + + PARCBufferPool *bufferPool = parcObjectDescriptor_GetTypeState(parcObject_GetDescriptor(buffer)); + + parcObject_Synchronize(bufferPool->freeList) + { + size_t freeListSize = parcLinkedList_Size(bufferPool->freeList); + + if (bufferPool->limit > freeListSize) { + parcLinkedList_Append(bufferPool->freeList, buffer); + freeListSize++; + if (bufferPool->largestPoolSize < freeListSize) { + bufferPool->largestPoolSize = freeListSize; + } + } else { + parcBuffer_Acquire(buffer); + parcObject_SetDescriptor(buffer, &PARCBuffer_Descriptor); + parcBuffer_Release(&buffer); + } + } + + *bufferPtr = 0; + return false; +} + +parcObject_ImplementAcquire(parcBufferPool, PARCBufferPool); + +parcObject_ImplementRelease(parcBufferPool, PARCBufferPool); + +parcObject_Override(PARCBufferPool, PARCObject, + .destructor = (PARCObjectDestructor *) _parcBufferPool_Destructor, + .isLockable = true); + + +void +parcBufferPool_AssertValid(const PARCBufferPool *instance) +{ + assertTrue(parcBufferPool_IsValid(instance), + "PARCBufferPool is not valid."); +} + +PARCBufferPool * +parcBufferPool_CreateExtending(const PARCObjectDescriptor *originalDescriptor, size_t limit, size_t bufferSize) +{ + PARCBufferPool *result = parcObject_CreateInstance(PARCBufferPool); + + if (result != NULL) { + result->limit = limit; + result->totalInstances = 0; + result->cacheHits = 0; + result->largestPoolSize = 0; + result->bufferSize = bufferSize; + result->freeList = parcLinkedList_Create(); + + result->originalDescriptor = originalDescriptor; + + char *string = parcMemory_Format("PARCBufferPool=%zu", bufferSize); + result->descriptor = parcObjectDescriptor_CreateExtension(result->originalDescriptor, string); + result->descriptor->destructor = (PARCObjectDestructor *) _parcBufferPool_ObjectDestructor; + result->descriptor->typeState = (PARCObjectTypeState *) result; + parcMemory_Deallocate(&string); + } + + return result; +} + +PARCBufferPool * +parcBufferPool_Create(size_t limit, size_t bufferSize) +{ + PARCBufferPool *result = parcBufferPool_CreateExtending(&parcObject_DescriptorName(PARCBuffer), limit, bufferSize); + + return result; +} + +void +parcBufferPool_Display(const PARCBufferPool *instance, int indentation) +{ + parcDisplayIndented_PrintLine(indentation, "PARCBufferPool@%p {", instance); + /* Call Display() functions for the fields here. */ + parcDisplayIndented_PrintLine(indentation, "}"); +} + +bool +parcBufferPool_IsValid(const PARCBufferPool *bufferPool) +{ + bool result = false; + + if (bufferPool != NULL) { + result = parcLinkedList_IsValid(bufferPool->freeList); + } + + return result; +} + +PARCBuffer * +parcBufferPool_GetInstance(PARCBufferPool *bufferPool) +{ + PARCBuffer *result = NULL; + + parcObject_Synchronize(bufferPool->freeList) + { + if (parcLinkedList_Size(bufferPool->freeList) > 0) { + result = parcLinkedList_RemoveFirst(bufferPool->freeList); + bufferPool->cacheHits++; + } else { + result = parcBuffer_Allocate(bufferPool->bufferSize); + parcObject_SetDescriptor(result, bufferPool->descriptor); + } + bufferPool->totalInstances++; + } + + return result; +} + +size_t +parcBufferPool_Drain(PARCBufferPool *bufferPool) +{ + size_t result = 0; + + parcObject_Synchronize(bufferPool->freeList) + { + size_t freeListSize = parcLinkedList_Size(bufferPool->freeList); + if (freeListSize > bufferPool->limit) { + result = freeListSize - bufferPool->limit; + for (size_t i = bufferPool->limit; i < freeListSize; i++) { + PARCObject *object = parcLinkedList_RemoveLast(bufferPool->freeList); + parcObject_SetDescriptor(object, &PARCBuffer_Descriptor); + parcObject_Release(&object); + } + } + } + + return result; +} + +size_t +parcBufferPool_SetLimit(PARCBufferPool *bufferPool, size_t limit) +{ + size_t oldLimit = bufferPool->limit; + + if (limit < bufferPool->limit) { + bufferPool->largestPoolSize = bufferPool->limit; + } + + bufferPool->limit = limit; + + return oldLimit; +} + +size_t +parcBufferPool_GetLimit(const PARCBufferPool *bufferPool) +{ + return bufferPool->limit; +} + +size_t +parcBufferPool_GetCurrentPoolSize(const PARCBufferPool *bufferPool) +{ + size_t result = parcLinkedList_Size(bufferPool->freeList); + + return result; +} + +size_t +parcBufferPool_GetLargestPoolSize(const PARCBufferPool *bufferPool) +{ + return bufferPool->largestPoolSize; +} + +size_t +parcBufferPool_GetTotalInstances(const PARCBufferPool *bufferPool) +{ + return bufferPool->totalInstances; +} + +size_t +parcBufferPool_GetCacheHits(const PARCBufferPool *bufferPool) +{ + return bufferPool->cacheHits; +} diff --git a/libparc/parc/memory/parc_BufferPool.h b/libparc/parc/memory/parc_BufferPool.h new file mode 100644 index 00000000..33028920 --- /dev/null +++ b/libparc/parc/memory/parc_BufferPool.h @@ -0,0 +1,344 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed 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. + */ + +/** + * @file parc_BufferPool.h + * @ingroup memory + * @brief A simple pool of uniformly sized PARCBuffer instances. + * + * The client uses `parcBufferPool_GetInstance` to obtain instances which are placed attempted to be placed + * into the pool when the `PARCBuffer_Release` function is called. + * The pool has a maxmimum number of instances that it will cache. + * + */ +#ifndef PARCLibrary_parc_BufferPool +#define PARCLibrary_parc_BufferPool +#include + +#include + +parcObject_Declare(PARCBufferPool); + +/** + * Increase the number of references to a `PARCBufferPool` instance. + * + * Note that new `PARCBufferPool` is not created, + * only that the given `PARCBufferPool` reference count is incremented. + * Discard the reference by invoking `parcBufferPool_Release`. + * + * @param [in] instance A pointer to a valid PARCBufferPool instance. + * + * @return The same value as the parameter @p instance. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * PARCBufferPool *b = parcBufferPool_Acquire(a); + * + * parcBufferPool_Release(&a); + * parcBufferPool_Release(&b); + * } + * @endcode + */ +PARCBufferPool *parcBufferPool_Acquire(const PARCBufferPool *instance); + +#ifdef PARCLibrary_DISABLE_VALIDATION +# define parcBufferPool_OptionalAssertValid(_instance_) +#else +# define parcBufferPool_OptionalAssertValid(_instance_) parcBufferPool_AssertValid(_instance_) +#endif + +/** + * Assert that the given `PARCBufferPool` instance is valid. + * + * @param [in] instance A pointer to a valid PARCBufferPool instance. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * parcBufferPool_AssertValid(a); + * + * parcBufferPool_Release(&a); + * } + * @endcode + */ +void parcBufferPool_AssertValid(const PARCBufferPool *instance); + +/** + * Create an instance of PARCBufferPool containing instances of `PARCBuffer`. + * + * This function is equivalent to invoking + * @code + * PARCBufferPool *a = parcBufferPool_CreateExtending(&parcObject_DescriptorName(PARCBuffer), 5, 10); + * @endcode + * + * The value of @p limit is the maximum number of instances that the pool will cache, + * and @p bufferSize is the size of the `PARCBuffer` instances cached. + * + * @return non-NULL A pointer to a valid PARCBufferPool instance. + * @return NULL An error occurred. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * parcBufferPool_Release(&a); + * } + * @endcode + */ +PARCBufferPool *parcBufferPool_Create(size_t limit, size_t bufferSize); + +/** + * Create an instance of PARCBufferPool containing instances of object specified by the given `PARCObjectDescriptor`. + * + * The value of @p limit is the maximum number of instances that the pool will cache, + * and @p bufferSize is the size of the `PARCBuffer` instances cached. + * + * This function creates a PARCBufferPool that creates and manages instances of PARCBuffer which may have been extended. + * + * @return non-NULL A pointer to a valid PARCBufferPool instance. + * @return NULL An error occurred. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_CreateExtending(&parcObject_DescriptorName(MyPARCBuffer), 5, 10); + * + * parcBufferPool_Release(&a); + * } + * @endcode + */ +PARCBufferPool *parcBufferPool_CreateExtending(const PARCObjectDescriptor *originalDescriptor, size_t limit, size_t bufferSize); + +/** + * Print a human readable representation of the given `PARCBufferPool`. + * + * @param [in] instance A pointer to a valid PARCBufferPool instance. + * @param [in] indentation The indentation level to use for printing. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * parcBufferPool_Display(a, 0); + * + * parcBufferPool_Release(&a); + * } + * @endcode + */ +void parcBufferPool_Display(const PARCBufferPool *instance, int indentation); + +/** + * Determine if an instance of `PARCBufferPool` is valid. + * + * Valid means the internal state of the type is consistent with its required current or future behaviour. + * This may include the validation of internal instances of types. + * + * @param [in] instance A pointer to a valid PARCBufferPool instance. + * + * @return true The instance is valid. + * @return false The instance is not valid. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * if (parcBufferPool_IsValid(a)) { + * printf("Instance is valid.\n"); + * } + * + * parcBufferPool_Release(&a); + * } + * @endcode + * + */ +bool parcBufferPool_IsValid(const PARCBufferPool *instance); + +/** + * Release a previously acquired reference to the given `PARCBufferPool` instance, + * decrementing the reference count for the instance. + * + * The pointer to the instance is set to NULL as a side-effect of this function. + * + * If the invocation causes the last reference to the instance to be released, + * the instance is deallocated and the instance's implementation will perform + * additional cleanup and release other privately held references. + * + * @param [in,out] instancePtr A pointer to a pointer to the instance to release. + * + * Example: + * @code + * { + * PARCBufferPool *a = parcBufferPool_Create(5, 10); + * + * parcBufferPool_Release(&a); + * } + * @endcode + */ +void parcBufferPool_Release(PARCBufferPool **instancePtr); + +/** + * Get an instance of a `PARCBuffer`. + * + * If the PARCBufferPool contains a cached instance, it will be returned. + * Otherwise a new instance will be created. + * + * Any `PARCBuffer` instance which is later released, will be a candidate for caching by the given `PARCBufferPool`. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * + * @return non-NULL A pointer to a valid `PARCBuffer`. + * @return NULL An error occurred. + * + * Example: + * @code + * { + * + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +PARCBuffer *parcBufferPool_GetInstance(PARCBufferPool *bufferPool); + +/** + * Set the largest number of buffers the pool will cache. + * + * If the new limit is less than the current limit, and the current pool size is greater than the new limit, + * the number of buffers the pool will cache will decay as they are obtained and released from the pool during use. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * @param [in] limit the largest number of buffers the pool will cache. + * + * @return The previous value of the largest number of buffers the pool cached. + * + * Example: + * @code + * { + * + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * size_t limit = parcBufferPool_SetLimit(pool, 3); + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +size_t parcBufferPool_SetLimit(PARCBufferPool *bufferPool, size_t limit); + +/** + * Get the largest number of buffers the pool will cache. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * + * @return The value of the largest number of buffers the pool will cache. + * + * Example: + * @code + * { + * + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * size_t limit = parcBufferPool_GetLimit(pool); + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +size_t parcBufferPool_GetLimit(const PARCBufferPool *bufferPool); + +/** + * Get the current number of buffers the pool has cached. + * + * The value is always greater than or equal to 0 and less than or equal to the limit. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * + * @return the largest number of buffers the pool has ever cached. + * + * Example: + * @code + * { + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * size_t poolSize = parcBufferPool_GetCurrentPoolSize(pool); + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +size_t parcBufferPool_GetCurrentPoolSize(const PARCBufferPool *bufferPool); + +/** + * Get the largest number of buffers the pool has ever cached. + * + * The value is always greater than or equal to 0 and less than or equal to the limit. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * + * @return the largest number of buffers the pool has ever cached. + * + * Example: + * @code + * { + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * size_t allTimeHigh = parcBufferPool_GetLargestPoolSize(pool); + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +size_t parcBufferPool_GetLargestPoolSize(const PARCBufferPool *bufferPool); + +/** + * Forcibly drain the PARCBufferPool of an excess (more than the pool's limit) `PARCBuffer` instances. + * + * The number of PARCBuffer instances can exceed the PARCBufferPool's limit if `parcBufferPool_SetLimit` is used to set the limit + * to less than Pool's current pool size. + * + * @param [in] bufferPool A pointer to a valid PARCBufferPool instance. + * + * @return the largest number of buffers released from the Pool's cache. + * + * Example: + * @code + * { + * + * PARCBufferPool *pool = parcBufferPool_Create(5, 10); + * ... + * + * size_t limit = parcBufferPool_SetLimit(pool, 3); + * size_t drained = parcBufferPool_Drain(pool); + * + * parcBufferPool_Release(&pool); + * } + * @endcode + */ +size_t parcBufferPool_Drain(PARCBufferPool *bufferPool); +#endif diff --git a/libparc/parc/memory/test/CMakeLists.txt b/libparc/parc/memory/test/CMakeLists.txt new file mode 100644 index 00000000..61a5608b --- /dev/null +++ b/libparc/parc/memory/test/CMakeLists.txt @@ -0,0 +1,13 @@ +set(TestsExpectedToPass + test_parc_BufferPool + ) + +# Enable gcov output for the tests +add_definitions(--coverage) +set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} " --coverage") + +foreach(test ${TestsExpectedToPass}) + AddTest(${test}) +endforeach() + + diff --git a/libparc/parc/memory/test/test_parc_BufferPool.c b/libparc/parc/memory/test/test_parc_BufferPool.c new file mode 100644 index 00000000..b7c18d08 --- /dev/null +++ b/libparc/parc/memory/test/test_parc_BufferPool.c @@ -0,0 +1,370 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed 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. + */ + +/** + */ +#include "../parc_BufferPool.c" + +#include +#include +#include +#include +#include + +#include +#include + +LONGBOW_TEST_RUNNER(parc_BufferPool) +{ + // The following Test Fixtures will run their corresponding Test Cases. + // Test Fixtures are run in the order specified, but all tests should be idempotent. + // Never rely on the execution order of tests or share state between them. + LONGBOW_RUN_TEST_FIXTURE(CreateAcquireRelease); + LONGBOW_RUN_TEST_FIXTURE(Object); + LONGBOW_RUN_TEST_FIXTURE(Specialization); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(parc_BufferPool) +{ + parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory); + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(parc_BufferPool) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(CreateAcquireRelease) +{ + LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease); +} + +LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease) +{ + if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) { + parcSafeMemory_ReportAllocation(1); + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease) +{ + PARCBufferPool *instance = parcBufferPool_Create(3, 10); + assertNotNull(instance, "Expected non-null result from parcBufferPool_Create();"); + + parcObjectTesting_AssertAcquireReleaseContract(parcBufferPool_Acquire, instance); + + parcBufferPool_Release(&instance); + assertNull(instance, "Expected null result from parcBufferPool_Release();"); +} + +LONGBOW_TEST_FIXTURE(Object) +{ + LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_Display); + LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_IsValid); + LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_AssertValid); +} + +LONGBOW_TEST_FIXTURE_SETUP(Object) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Object) +{ + if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) { + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Object, parcBufferPool_Display) +{ + PARCBufferPool *instance = parcBufferPool_Create(3, 10); + parcBufferPool_Display(instance, 0); + parcBufferPool_Release(&instance); +} + +LONGBOW_TEST_CASE(Object, parcBufferPool_IsValid) +{ + PARCBufferPool *instance = parcBufferPool_Create(3, 10); + assertTrue(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Create to result in a valid instance."); + + parcBufferPool_Release(&instance); + assertFalse(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Release to result in an invalid instance."); +} + +LONGBOW_TEST_CASE(Object, parcBufferPool_AssertValid) +{ + PARCBufferPool *instance = parcBufferPool_Create(3, 10); + parcBufferPool_AssertValid(instance); + + parcBufferPool_Release(&instance); + assertFalse(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Release to result in an invalid instance."); +} + +LONGBOW_TEST_FIXTURE(Specialization) +{ + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetInstance); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetLargestPoolSize); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetCurrentPoolSize); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetTotalInstances); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetCacheHits); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetLimit); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_SetLimit_Increasing); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_SetLimit_Decreasing); + LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_Drain); +} + +LONGBOW_TEST_FIXTURE_SETUP(Specialization) +{ + longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding()); + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization) +{ + int initialAllocations = longBowTestCase_GetInt(testCase, "initialAllocations"); + + if (parcMemory_Outstanding() > initialAllocations) { + parcSafeMemory_ReportAllocation(1); + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetInstance) +{ + PARCBufferPool *pool = parcBufferPool_Create(3, 10); + + PARCBuffer *buffer = parcBufferPool_GetInstance(pool); + + parcBuffer_AssertValid(buffer); + parcBuffer_Release(&buffer); + + size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool); + + assertTrue(largestPoolSize == 1, "Expected the largestPoolSize to be 1, actual %zu", largestPoolSize); + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetLargestPoolSize) +{ + PARCBufferPool *pool = parcBufferPool_Create(3, 10); + size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool); + + assertTrue(largestPoolSize == 0, "Expected the largestPoolSize to be 0, actual %zu", largestPoolSize); + + PARCBuffer *buffer = parcBufferPool_GetInstance(pool); + + parcBuffer_AssertValid(buffer); + parcBuffer_Release(&buffer); + + largestPoolSize = parcBufferPool_GetLargestPoolSize(pool); + + assertTrue(largestPoolSize == 1, "Expected the largestPoolSize to be 1, actual %zu", largestPoolSize); + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetTotalInstances) +{ + PARCBufferPool *pool = parcBufferPool_Create(3, 10); + size_t totalInstances = parcBufferPool_GetTotalInstances(pool); + + assertTrue(totalInstances == 0, "Expected the totalInstances to be 0, actual %zu", totalInstances); + + PARCBuffer *buffer = parcBufferPool_GetInstance(pool); + + parcBuffer_AssertValid(buffer); + parcBuffer_Release(&buffer); + + totalInstances = parcBufferPool_GetTotalInstances(pool); + + assertTrue(totalInstances == 1, "Expected the totalInstances to be 1, actual %zu", totalInstances); + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetCacheHits) +{ + PARCBufferPool *pool = parcBufferPool_Create(3, 10); + size_t cacheHits = parcBufferPool_GetCacheHits(pool); + + assertTrue(cacheHits == 0, "Expected the cacheHits to be 0, actual %zu", cacheHits); + + PARCBuffer *buffer = parcBufferPool_GetInstance(pool); + parcBuffer_AssertValid(buffer); + parcBuffer_Release(&buffer); + + cacheHits = parcBufferPool_GetCacheHits(pool); + assertTrue(cacheHits == 0, "Expected the cacheHits to be 0, actual %zu", cacheHits); + + buffer = parcBufferPool_GetInstance(pool); + parcBuffer_AssertValid(buffer); + parcBuffer_Release(&buffer); + + cacheHits = parcBufferPool_GetCacheHits(pool); + assertTrue(cacheHits == 1, "Expected the cacheHits to be 1, actual %zu", cacheHits); + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetLimit) +{ + size_t expected = 20; + + PARCBufferPool *pool = parcBufferPool_Create(expected, 10); + size_t limit = parcBufferPool_GetLimit(pool); + + assertTrue(limit == expected, "Expected the limit to be %zu, actual %zu", expected, limit); + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetCurrentPoolSize) +{ + size_t expectedLimit = 3; + + PARCBufferPool *pool = parcBufferPool_Create(expectedLimit, 10); + size_t poolSize = parcBufferPool_GetCurrentPoolSize(pool); + + assertTrue(poolSize == 0, "Expected the poolSize to be 0, actual %zu", poolSize); + + PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer4 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer5 = parcBufferPool_GetInstance(pool); + + parcBuffer_Release(&buffer1); + parcBuffer_Release(&buffer2); + parcBuffer_Release(&buffer3); + parcBuffer_Release(&buffer4); + parcBuffer_Release(&buffer5); + + poolSize = parcBufferPool_GetCurrentPoolSize(pool); + + assertTrue(poolSize == expectedLimit, "Expected the poolSize to be %zu, actual %zu", expectedLimit, poolSize); + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_SetLimit_Increasing) +{ + size_t oldLimit = 3; + size_t newLimit = 5; + + PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10); + size_t limit = parcBufferPool_GetLimit(pool); + + assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit); + + PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool); + parcBuffer_AssertValid(buffer1); + parcBuffer_AssertValid(buffer2); + parcBuffer_AssertValid(buffer3); + parcBuffer_Release(&buffer1); + parcBuffer_Release(&buffer2); + parcBuffer_Release(&buffer3); + + limit = parcBufferPool_SetLimit(pool, newLimit); + assertTrue(limit == 3, "Expected the old limit to be %zu, actual %zu", oldLimit, limit); + + size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool); + assertTrue(largestPoolSize == oldLimit, "Expected largest pool size to be %zu, actual %zu", oldLimit, largestPoolSize); + + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_SetLimit_Decreasing) +{ + size_t oldLimit = 3; + size_t newLimit = 2; + + PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10); + size_t limit = parcBufferPool_GetLimit(pool); + + assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit); + + PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool); + parcBuffer_AssertValid(buffer1); + parcBuffer_AssertValid(buffer2); + parcBuffer_AssertValid(buffer3); + parcBuffer_Release(&buffer1); + parcBuffer_Release(&buffer2); + parcBuffer_Release(&buffer3); + + limit = parcBufferPool_SetLimit(pool, newLimit); + assertTrue(limit == 3, "Expected the old limit to be %zu, actual %zu", oldLimit, limit); + + size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool); + assertTrue(largestPoolSize == oldLimit, "Expected largest pool size to be %zu, actual %zu", oldLimit, largestPoolSize); + + + parcBufferPool_Release(&pool); +} + +LONGBOW_TEST_CASE(Specialization, parcBufferPool_Drain) +{ + size_t oldLimit = 3; + size_t newLimit = 2; + + PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10); + + PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool); + PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool); + parcBuffer_AssertValid(buffer1); + parcBuffer_AssertValid(buffer2); + parcBuffer_AssertValid(buffer3); + parcBuffer_Release(&buffer1); + parcBuffer_Release(&buffer2); + parcBuffer_Release(&buffer3); + + size_t limit = parcBufferPool_SetLimit(pool, newLimit); + assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit); + + size_t drained = parcBufferPool_Drain(pool); + assertTrue(drained == 1, "Expected the drained to be 1, actual %zu", drained); + + parcBufferPool_Release(&pool); +} + +int +main(int argc, char *argv[argc]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_BufferPool); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} -- cgit 1.2.3-korg