www.pudn.com > allocator.rar > pool.cc


// file: test/pool.cc
// author: Marc Bumble
// Mon Aug 11, 2003
// Memory allocator code for shared memory access
// Copyright (C) 2003 by Marc D. Bumble

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


#include <pooled_allocator.h>
#include <fstream> // for std::ofstream to()

char key_val1[] = "/allocate_key";
char key_val2[] = "/allocate_key2";
char key_addr1[] = "0x400d0000";
char key_addr2[] = "0x408d0000";

int main(int argc, char **argv) {

int passed=0, failed=0;

// make sure key shared memory segment is not in use
// shm_unlink(key_val1);
// shm_unlink(key_val2);

std::cerr << "----------------------------------------" << std::endl;
std::cerr << "Shared memory class test. " << std::endl;

/////////////////////////////////////////////////////////////////////
//////
////// Shared Pool and Chunk tests start here
//////
/////////////////////////////////////////////////////////////////////

pooled_allocator::Pool<int,key_val1,key_addr1>
pool_obj1;
std::cerr << "\tAllocate test: 50 elements" << std::endl;
mem_space::memory_index_t mem_idx1 =
pool_obj1.alloc(50);
// mem_idx1.print();
if (mem_idx1.get_memory_ptr() != 0)
passed++;
else
failed++;
std::cerr << "\tCopy Constructor test" << std::endl;
pooled_allocator::Pool<int,key_val1,key_addr1>
pool_obj2(pool_obj1);
if (pool_obj1==pool_obj2)
passed++;
else
failed++;
std::cerr << "\tAssignment test" << std::endl;
pooled_allocator::Pool<int,key_val1,key_addr1>
pool_obj3=pool_obj1;
if (pool_obj1==pool_obj3)
passed++;
else
failed++;
// std::cerr << "\tDestructor test" << std::endl;
// pool_obj2.~Pool();
std::cerr << "\tAllocate test: 50 elements" << std::endl;
mem_space::memory_index_t mem_idx2 =
pool_obj2.alloc(50);
// mem_idx2.print();
if (mem_idx2.get_memory_ptr() != 0)
passed++;
else
failed++;
std::cerr << "\tAllocate test: 4000 elements" << std::endl;
mem_space::memory_index_t mem_idx3 =
pool_obj2.alloc(4000);
// mem_idx3.print();
if (mem_idx3.get_memory_ptr() != 0)
passed++;
else
failed++;
std::cerr << "\tAllocate test: 100 elements" << std::endl;
mem_space::memory_index_t mem_idx4 =
pool_obj2.alloc(100);
// mem_idx4.print();
if (mem_idx4.get_memory_ptr() != 0)
passed++;
else
failed++;
std::cerr << "\tAllocate test: 30000 elements" << std::endl;
mem_space::memory_index_t mem_idx5 =
pool_obj1.alloc(30000);
// mem_idx5.print();
if (mem_idx5.get_memory_ptr() != 0)
passed++;
else
failed++;
pool_obj1.free(static_cast<unsigned char*>(mem_idx1.get_memory_ptr()),50);
pool_obj2.free(static_cast<unsigned char*>(mem_idx2.get_memory_ptr()),50);
pool_obj2.free(static_cast<unsigned char*>(mem_idx3.get_memory_ptr()),4000);

pool_obj2.free(static_cast<unsigned char*>(mem_idx4.get_memory_ptr()),100);
pool_obj1.free(static_cast<unsigned char*>(mem_idx5.get_memory_ptr()),30000);

/////////////////////////////////////////////////////////////////////
//////
////// Shared Pooled allocator tests start here
//////
/////////////////////////////////////////////////////////////////////

pooled_allocator::Pool_alloc<int,
key_val2,
key_addr2> pool_alloc_obj;

int* buff1 = pool_alloc_obj.allocate(50);
int* buff2 = pool_alloc_obj.allocate(30000);
int* buff3 = pool_alloc_obj.allocate(100);
pool_alloc_obj.deallocate(buff1,50);
pool_alloc_obj.deallocate(buff2,30000);
pool_alloc_obj.deallocate(buff3,100);

// close out semaphore arrays. Do this after using Pool_alloc object
// as Pool_alloc object does not have a shutdown method call
// pool_obj1.shutdown();
// pool_obj2.shutdown();
// pooled_allocator::Pool<int,key_val2,key_addr2>
// pool_obj4;
// pool_obj4.shutdown();

std::cerr << "Passed: " << passed << std::endl;
std::cerr << "Failed: " << failed << std::endl;
std::cerr << "\t" << std::endl;
std::cerr << "----------------------------------------" << std::endl;


return 0;
}