containers/tpie_stack_benchmark.cpp

This is a benchmark mentioned in the paper R. Dementiev, L. Kettner, P. Sanders "STXXL: standard template library for XXL data sets" Software: Practice and Experience Volume 38, Issue 6, Pages 589-637, May 2008 DOI: 10.1002/spe.844

00001 /***************************************************************************
00002  *  containers/tpie_stack_benchmark.cpp
00003  *
00004  *  Part of the STXXL. See http://stxxl.sourceforge.net
00005  *
00006  *  Copyright (C) 2006 Roman Dementiev <dementiev@ira.uka.de>
00007  *
00008  *  Distributed under the Boost Software License, Version 1.0.
00009  *  (See accompanying file LICENSE_1_0.txt or copy at
00010  *  http://www.boost.org/LICENSE_1_0.txt)
00011  **************************************************************************/
00012 
00019 
00020 
00021 #include "app_config.h"
00022 
00023 #include <portability.h>
00024 #include <versions.h>
00025 
00026 // Get the AMI_stack definition.
00027 #include <ami_stack.h>
00028 
00029 // Utilities for ASCII output.
00030 #include <ami_scan_utils.h>
00031 
00032 #include <stxxl/bits/common/utils.h>
00033 #include <stxxl/timer>
00034 
00035 
00036 #define MEM_2_RESERVE    (768 * 1024 * 1024)
00037 
00038 #define BLOCK_SIZE       (2 * 1024 * 1024)
00039 
00040 
00041 #ifndef DISKS
00042  #define DISKS 1
00043 #endif
00044 
00045 template <unsigned RECORD_SIZE>
00046 struct my_record_
00047 {
00048     char data[RECORD_SIZE];
00049     my_record_() { }
00050 };
00051 
00052 
00053 template <class my_record>
00054 void run_stack(stxxl::int64 volume)
00055 {
00056     typedef AMI_stack<my_record> stack_type;
00057 
00058     MM_manager.set_memory_limit(BLOCK_SIZE * DISKS * 8);
00059 
00060     STXXL_MSG("Record size: " << sizeof(my_record) << " bytes");
00061 
00062     stack_type Stack;
00063 
00064     stxxl::int64 ops = volume / sizeof(my_record);
00065 
00066     stxxl::int64 i;
00067 
00068     my_record cur;
00069 
00070     stxxl::timer Timer;
00071     Timer.start();
00072 
00073     for (i = 0; i < ops; ++i)
00074     {
00075         Stack.push(cur);
00076     }
00077 
00078     Timer.stop();
00079 
00080     STXXL_MSG("Records in Stack: " << Stack.stream_len());
00081     if (i != Stack.stream_len())
00082     {
00083         STXXL_MSG("Size does not match");
00084         abort();
00085     }
00086 
00087     STXXL_MSG("Insertions elapsed time: " << (Timer.mseconds() / 1000.) <<
00088               " seconds : " << (double(volume) / (1024. * 1024. * Timer.mseconds() / 1000.)) <<
00089               " MB/s");
00090 
00091 
00093     Timer.reset();
00094     Timer.start();
00095 
00096     my_record * out;
00097 
00098     for (i = 0; i < ops; ++i)
00099     {
00100         Stack.pop(&out);
00101     }
00102 
00103     Timer.stop();
00104 
00105     STXXL_MSG("Records in Stack: " << Stack.stream_len());
00106     if (Stack.stream_len() != 0)
00107     {
00108         STXXL_MSG("Stack must be empty");
00109         abort();
00110     }
00111 
00112     STXXL_MSG("Deletions elapsed time: " << (Timer.mseconds() / 1000.) <<
00113               " seconds : " << (double(volume) / (1024. * 1024. * Timer.mseconds() / 1000.)) <<
00114               " MB/s");
00115 }
00116 
00117 
00118 int main(int argc, char * argv[])
00119 {
00120     using std::cout;
00121     using std::endl;
00122 #ifdef BTE_COLLECTION_IMP_MMAP
00123     cout << "BTE_COLLECTION_IMP_MMAP is defined" << endl;
00124 #endif
00125 #ifdef BTE_COLLECTION_IMP_UFS
00126     cout << "BTE_COLLECTION_IMP_UFS is defined" << endl;
00127 #endif
00128 #ifdef BTE_STREAM_IMP_UFS
00129     cout << "BTE_STREAM_IMP_UFS is defined" << endl;
00130     cout << "BTE_STREAM_UFS_BLOCK_FACTOR is " << BTE_STREAM_UFS_BLOCK_FACTOR << endl;
00131     cout << "Actual block size is " << (TPIE_OS_BLOCKSIZE() * BTE_STREAM_UFS_BLOCK_FACTOR / 1024) << " KB" << endl;
00132 #endif
00133 #ifdef BTE_STREAM_IMP_MMAP
00134     cout << "BTE_STREAM_IMP_MMAP is defined" << endl;
00135     cout << "BTE_STREAM_MMAP_BLOCK_FACTOR is " << BTE_STREAM_MMAP_BLOCK_FACTOR << endl;
00136     cout << "Actual block size is " << (TPIE_OS_BLOCKSIZE() * BTE_STREAM_MMAP_BLOCK_FACTOR / 1024) << " KB" << endl;
00137 #endif
00138 #ifdef BTE_STREAM_IMP_STDIO
00139     cout << "BTE_STREAM_IMP_STDIO is defined" << endl;
00140 #endif
00141     cout << "TPIE_OS_BLOCKSIZE() is " << TPIE_OS_BLOCKSIZE() << endl;
00142 
00143     if (argc < 3)
00144     {
00145         STXXL_MSG("Usage: " << argv[0] << " version #volume");
00146         STXXL_MSG("\t version = 1: TPIE stack with 4 byte records");
00147         STXXL_MSG("\t version = 2: TPIE stack with 32 byte records");
00148         return -1;
00149     }
00150 
00151     int version = atoi(argv[1]);
00152     stxxl::int64 volume = stxxl::atoint64(argv[2]);
00153 
00154     STXXL_MSG("Allocating array with size " << MEM_2_RESERVE
00155                                             << " bytes to prevent file buffering.");
00156     //int * array = new int[MEM_2_RESERVE/sizeof(int)];
00157     int * array = (int *)malloc(MEM_2_RESERVE);
00158     std::fill(array, array + (MEM_2_RESERVE / sizeof(int)), 0);
00159 
00160     STXXL_MSG("Running version: " << version);
00161     STXXL_MSG("Data volume    : " << volume << " bytes");
00162 
00163     switch (version)
00164     {
00165     case 1:
00166         run_stack<my_record_<4> >(volume);
00167         break;
00168     case 2:
00169         run_stack<my_record_<32> >(volume);
00170         break;
00171     default:
00172         STXXL_MSG("Unsupported version " << version);
00173     }
00174 
00175     //delete [] array;
00176     free(array);
00177 }

Generated on Thu Jun 4 10:30:00 2009 for Stxxl by  doxygen 1.4.7