15 #ifndef STXXL_MNG_HEADER
16 #define STXXL_MNG_HEADER
29 #ifdef STXXL_BOOST_CONFIG
30 #include <boost/config.hpp>
37 #include <stxxl/bits/io/iobase.h>
38 #include <stxxl/bits/noncopyable.h>
39 #include <stxxl/bits/common/rand.h>
40 #include <stxxl/bits/common/aligned_alloc.h>
41 #include <stxxl/bits/common/debug.h>
42 #include <stxxl/bits/parallel.h>
43 #include <stxxl/bits/singleton.h>
45 #ifndef STXXL_VERBOSE_BLOCK_LIFE_CYCLE
46 #define STXXL_VERBOSE_BLOCK_LIFE_CYCLE STXXL_VERBOSE2
48 #define FMT_BID(_bid_) "[" << (_bid_).storage->get_id() << "]0x" << std::hex << std::setfill('0') << std::setw(8) << (_bid_).offset << "/0x" << std::setw(8) << (_bid_).size
51 __STXXL_BEGIN_NAMESPACE
61 template <
unsigned SIZE>
78 template <
unsigned BlockSize>
104 template <
unsigned blk_sz>
110 template <
unsigned blk_sz>
117 template <
unsigned blk_sz>
118 std::ostream & operator << (std::ostream & s, const BID<blk_sz> & bid)
120 s <<
" storage file addr: " << bid.storage;
121 s <<
" offset: " << bid.offset;
122 s <<
" size: " << bid.
size;
127 template <
unsigned bytes>
128 class filler_struct__
130 typedef unsigned char byte_type;
131 byte_type filler_array_[bytes];
134 filler_struct__() { STXXL_VERBOSE2(
"filler_struct__ is allocated"); }
138 class filler_struct__<0>
140 typedef unsigned char byte_type;
143 filler_struct__() { STXXL_VERBOSE2(
"filler_struct__ is allocated"); }
147 template <
class T,
unsigned Size_>
152 typedef T value_type;
153 typedef T & reference;
154 typedef const T & const_reference;
155 typedef type * pointer;
156 typedef pointer iterator;
157 typedef const type * const_iterator;
167 element_block() { STXXL_VERBOSE2(
"element_block is allocated"); }
196 const_iterator
end()
const
208 template <
class T,
unsigned Size_,
unsigned RawSize_,
unsigned NB
ids_ = 0>
228 block_w_bids() { STXXL_VERBOSE2(
"block_w_bids is allocated"); }
231 template <
class T,
unsigned Size_,
unsigned RawSize_>
242 block_w_bids() { STXXL_VERBOSE2(
"block_w_bids is allocated"); }
246 template <
class T_,
unsigned RawSize_,
unsigned NB
ids_,
class InfoType_ =
void>
248 public block_w_bids<T_, ((RawSize_ - sizeof(BID<RawSize_>) * NBids_ - sizeof(InfoType_)) / sizeof(T_)), RawSize_, NBids_>
257 enum { size = ((RawSize_ -
sizeof(
BID<RawSize_>) * NBids_ -
sizeof(InfoType_)) /
sizeof(T_)) };
260 block_w_info() { STXXL_VERBOSE2(
"block_w_info is allocated"); }
263 template <
class T_,
unsigned RawSize_,
unsigned NB
ids_>
265 public block_w_bids<T_, ((RawSize_ - sizeof(BID<RawSize_>) * NBids_) / sizeof(T_)), RawSize_, NBids_>
269 enum { size = ((RawSize_ -
sizeof(
BID<RawSize_>) * NBids_) /
sizeof(T_)) };
272 block_w_info() { STXXL_VERBOSE2(
"block_w_info is allocated"); }
289 template <
unsigned RawSize_,
class T_,
unsigned NRef_ = 0,
class InfoType_ =
void>
292 public filler_struct__<(RawSize_ - sizeof(block_w_info<T_, RawSize_, NRef_, InfoType_>))>
296 typedef T_ value_type;
297 typedef T_ & reference;
298 typedef const T_ & const_reference;
299 typedef type * pointer;
300 typedef pointer iterator;
301 typedef type
const * const_iterator;
309 STXXL_VERBOSE2(
"typed_block is allocated");
326 STXXL_VERBOSE_BLOCK_LIFE_CYCLE(
"BLC:write " << FMT_BID(bid));
342 STXXL_VERBOSE_BLOCK_LIFE_CYCLE(
"BLC:read " << FMT_BID(bid));
346 static void *
operator new[] (
size_t bytes)
348 unsigned_type meta_info_size = bytes % raw_size;
349 STXXL_VERBOSE1(
"typed::block operator new[]: Meta info size: " << meta_info_size);
351 void * result = aligned_alloc<BLOCK_ALIGN>(bytes, meta_info_size);
352 #ifdef STXXL_VALGRIND_TYPED_BLOCK_INITIALIZE_ZERO
353 memset(result, 0, bytes);
355 char * tmp = (
char *)result;
356 STXXL_DEBUGMON_DO(block_allocated(tmp, tmp + bytes, RawSize_));
358 while (tmp < ((
char *)result) + bytes)
360 STXXL_DEBUGMON_DO(block_allocated(tmp, ((
char *)result) + bytes, RawSize_));
366 static void *
operator new (
size_t bytes)
368 unsigned_type meta_info_size = bytes % raw_size;
369 STXXL_VERBOSE1(
"typed::block operator new: Meta info size: " << meta_info_size);
371 void * result = aligned_alloc<BLOCK_ALIGN>(bytes, meta_info_size);
372 #ifdef STXXL_VALGRIND_TYPED_BLOCK_INITIALIZE_ZERO
373 memset(result, 0, bytes);
375 char * tmp = (
char *)result;
376 STXXL_DEBUGMON_DO(block_allocated(tmp, tmp + bytes, RawSize_));
378 while (tmp < ((
char *)result) + bytes)
380 STXXL_DEBUGMON_DO(block_allocated(tmp, ((
char *)result) + bytes, RawSize_));
386 static void *
operator new (
size_t ,
void * ptr)
391 static void operator delete[] (
void * ptr)
393 STXXL_DEBUGMON_DO(block_deallocated((
char *)ptr));
394 aligned_dealloc<BLOCK_ALIGN>(ptr);
397 static void operator delete (
void * ptr)
399 STXXL_DEBUGMON_DO(block_deallocated((
char *)ptr));
400 aligned_dealloc<BLOCK_ALIGN>(ptr);
403 static void operator delete (
void *,
void *)
420 template <
unsigned BLK_SIZE>
421 class BIDArray :
public std::vector<BID<BLK_SIZE> >
428 template <
unsigned BLK_SIZE>
429 class BIDArray :
private noncopyable
439 BIDArray() : _size(0), array(NULL)
447 return array + _size;
450 BIDArray(unsigned_type size) : _size(size)
454 unsigned_type size()
const
462 void resize(unsigned_type newsize)
466 STXXL_MSG(
"Warning: resizing nonempty BIDArray");
469 memcpy((
void *)array, (
void *)tmp,
488 class DiskAllocator :
private noncopyable
492 typedef std::pair<stxxl::int64, stxxl::int64> place;
493 struct FirstFit :
public std::binary_function<place, stxxl::int64, bool>
497 const stxxl::int64 size)
const
499 return (entry.second >= size);
504 bool operator () (
const stxxl::int64 & off1,
const stxxl::int64 & off2)
514 typedef std::map<stxxl::int64, stxxl::int64> sortseq;
517 stxxl::int64 free_bytes;
518 stxxl::int64 disk_bytes;
522 void check_corruption(stxxl::int64 region_pos, stxxl::int64 region_size,
523 sortseq::iterator pred, sortseq::iterator succ)
525 if (pred != free_space.end())
527 if (pred->first <= region_pos && pred->first + pred->second > region_pos)
529 STXXL_THROW(bad_ext_alloc,
"DiskAllocator::check_corruption",
"Error: double deallocation of external memory " <<
530 "System info: P " << pred->first <<
" " << pred->second <<
" " << region_pos);
533 if (succ != free_space.end())
535 if (region_pos <= succ->first && region_pos + region_size > succ->first)
537 STXXL_THROW(bad_ext_alloc,
"DiskAllocator::check_corruption",
"Error: double deallocation of external memory "
538 <<
"System info: S " << region_pos <<
" " << region_size <<
" " << succ->first);
544 inline DiskAllocator(stxxl::int64 disk_size);
546 inline stxxl::int64 get_free_bytes()
const
550 inline stxxl::int64 get_used_bytes()
const
552 return disk_bytes - free_bytes;
554 inline stxxl::int64 get_total_bytes()
const
559 template <
unsigned BLK_SIZE>
560 stxxl::int64 new_blocks(BIDArray<BLK_SIZE> & bids);
562 template <
unsigned BLK_SIZE>
566 template <
unsigned BLK_SIZE>
567 void delete_blocks(
const BIDArray<BLK_SIZE> & bids);
569 template <
unsigned BLK_SIZE>
573 DiskAllocator::DiskAllocator(stxxl::int64 disk_size) :
574 free_bytes(disk_size),
575 disk_bytes(disk_size)
577 free_space[0] = disk_size;
581 template <
unsigned BLK_SIZE>
582 stxxl::int64 DiskAllocator::new_blocks(BIDArray<BLK_SIZE> & bids)
584 return new_blocks(bids.begin(), bids.end());
587 template <
unsigned BLK_SIZE>
588 stxxl::int64 DiskAllocator::new_blocks(
BID<BLK_SIZE> * begin,
593 STXXL_VERBOSE2(
"DiskAllocator::new_blocks<BLK_SIZE>, BLK_SIZE = " << BLK_SIZE <<
594 ", free:" << free_bytes <<
" total:" << disk_bytes <<
595 ", blocks: " << (end - begin) <<
596 " begin: " << ((
void *)(begin)) <<
" end: " << ((
void *)(end)));
598 stxxl::int64 requested_size = 0;
601 for ( ; cur != end; ++cur)
603 STXXL_VERBOSE2(
"Asking for a block with size: " << (cur->
size));
604 requested_size += cur->
size;
607 if (free_bytes < requested_size)
609 STXXL_ERRMSG(
"External memory block allocation error: " << requested_size <<
610 " bytes requested, " << free_bytes <<
611 " bytes free. Trying to extend the external memory space...");
614 begin->
offset = disk_bytes;
615 for (++begin; begin != end; ++begin)
617 begin->
offset = (begin - 1)->offset + (begin - 1)->size;
619 disk_bytes += requested_size;
626 sortseq::iterator space =
627 std::find_if(free_space.begin(), free_space.end(),
628 bind2nd(FirstFit(), requested_size));
630 if (space != free_space.end())
632 stxxl::int64 region_pos = (*space).first;
633 stxxl::int64 region_size = (*space).second;
634 free_space.erase(space);
635 if (region_size > requested_size)
636 free_space[region_pos + requested_size] = region_size - requested_size;
638 begin->
offset = region_pos;
639 for (++begin; begin != end; ++begin)
641 begin->
offset = (begin - 1)->offset + (begin - 1)->size;
643 free_bytes -= requested_size;
650 STXXL_VERBOSE1(
"Warning, when allocating an external memory space, no contiguous region found");
651 STXXL_VERBOSE1(
"It might harm the performance");
652 if (requested_size == BLK_SIZE)
654 assert(end - begin == 1);
656 STXXL_ERRMSG(
"Warning: Severe external memory space fragmentation!");
659 STXXL_ERRMSG(
"External memory block allocation error: " << requested_size <<
660 " bytes requested, " << free_bytes <<
661 " bytes free. Trying to extend the external memory space...");
663 begin->
offset = disk_bytes;
664 disk_bytes += BLK_SIZE;
669 assert(requested_size > BLK_SIZE);
670 assert(end - begin > 1);
675 new_blocks(begin, middle);
676 new_blocks(middle, end);
682 template <
unsigned BLK_SIZE>
687 STXXL_VERBOSE2(
"DiskAllocator::delete_block<BLK_SIZE>, BLK_SIZE = " << BLK_SIZE
688 <<
", free:" << free_bytes <<
" total:" << disk_bytes);
689 STXXL_VERBOSE2(
"Deallocating a block with size: " << bid.
size);
693 stxxl::int64 region_pos = bid.
offset;
694 stxxl::int64 region_size = bid.
size;
695 STXXL_VERBOSE2(
"Deallocating a block with size: " << region_size <<
" position: " << region_pos);
696 if (!free_space.empty())
698 sortseq::iterator succ = free_space.upper_bound(region_pos);
699 sortseq::iterator pred = succ;
701 check_corruption(region_pos, region_size, pred, succ);
702 if (succ == free_space.end())
704 if (pred == free_space.end())
706 STXXL_ERRMSG(
"Error deallocating block at " << bid.
offset <<
" size " << bid.
size);
707 STXXL_ERRMSG(((pred == succ) ?
"pred==succ" :
"pred!=succ"));
708 STXXL_ERRMSG(((pred == free_space.begin()) ?
"pred==free_space.begin()" :
"pred!=free_space.begin()"));
709 STXXL_ERRMSG(((pred == free_space.end()) ?
"pred==free_space.end()" :
"pred!=free_space.end()"));
710 STXXL_ERRMSG(((succ == free_space.begin()) ?
"succ==free_space.begin()" :
"succ!=free_space.begin()"));
711 STXXL_ERRMSG(((succ == free_space.end()) ?
"succ==free_space.end()" :
"succ!=free_space.end()"));
713 assert(pred != free_space.end());
715 if ((*pred).first + (*pred).second == region_pos)
718 region_size += (*pred).second;
719 region_pos = (*pred).first;
720 free_space.erase(pred);
725 if (free_space.size() > 1)
730 STXXL_ERRMSG(
"Error deallocating block at " << bid.
offset <<
" size " << bid.
size);
731 STXXL_ERRMSG(((pred == succ) ?
"pred==succ" :
"pred!=succ"));
732 STXXL_ERRMSG(((pred == free_space.begin()) ?
"pred==free_space.begin()" :
"pred!=free_space.begin()"));
733 STXXL_ERRMSG(((pred == free_space.end()) ?
"pred==free_space.end()" :
"pred!=free_space.end()"));
734 STXXL_ERRMSG(((succ == free_space.begin()) ?
"succ==free_space.begin()" :
"succ!=free_space.begin()"));
735 STXXL_ERRMSG(((succ == free_space.end()) ?
"succ==free_space.end()" :
"succ!=free_space.end()"));
737 assert(pred != succ);
740 bool succ_is_not_the_first = (succ != free_space.begin());
741 if ((*succ).first == region_pos + region_size)
744 region_size += (*succ).second;
745 free_space.erase(succ);
747 if (succ_is_not_the_first)
749 if (pred == free_space.end())
751 STXXL_ERRMSG(
"Error deallocating block at " << bid.
offset <<
" size " << bid.
size);
752 STXXL_ERRMSG(((pred == succ) ?
"pred==succ" :
"pred!=succ"));
753 STXXL_ERRMSG(((pred == free_space.begin()) ?
"pred==free_space.begin()" :
"pred!=free_space.begin()"));
754 STXXL_ERRMSG(((pred == free_space.end()) ?
"pred==free_space.end()" :
"pred!=free_space.end()"));
755 STXXL_ERRMSG(((succ == free_space.begin()) ?
"succ==free_space.begin()" :
"succ!=free_space.begin()"));
756 STXXL_ERRMSG(((succ == free_space.end()) ?
"succ==free_space.end()" :
"succ!=free_space.end()"));
758 assert(pred != free_space.end());
760 if ((*pred).first + (*pred).second == region_pos)
763 region_size += (*pred).second;
764 region_pos = (*pred).first;
765 free_space.erase(pred);
771 if ((*succ).first == region_pos + region_size)
774 region_size += (*succ).second;
775 free_space.erase(succ);
781 free_space[region_pos] = region_size;
782 free_bytes += stxxl::int64(bid.
size);
788 template <
unsigned BLK_SIZE>
789 void DiskAllocator::delete_blocks(
const BIDArray<BLK_SIZE> & bids)
791 STXXL_VERBOSE2(
"DiskAllocator::delete_blocks<BLK_SIZE> BLK_SIZE=" << BLK_SIZE <<
792 ", free:" << free_bytes <<
" total:" << disk_bytes);
795 for ( ; i < bids.size(); ++i)
797 stxxl::int64 region_pos = bids[i].offset;
798 stxxl::int64 region_size = bids[i].size;
799 STXXL_VERBOSE2(
"Deallocating a block with size: " << region_size);
800 assert(bids[i].size);
802 if (!free_space.empty())
804 sortseq::iterator succ =
805 free_space.upper_bound(region_pos);
806 sortseq::iterator pred = succ;
809 if (succ != free_space.end()
810 && (*succ).first == region_pos + region_size)
814 region_size += (*succ).second;
815 free_space.erase(succ);
817 if (pred != free_space.end()
818 && (*pred).first + (*pred).second == region_pos)
822 region_size += (*pred).second;
823 region_pos = (*pred).first;
824 free_space.erase(pred);
827 free_space[region_pos] = region_size;
829 for (i = 0; i < bids.size(); ++i)
830 free_bytes += stxxl::int64(bids[i].size);
838 friend class singleton<config>;
847 std::vector<DiskEntry> disks_props;
850 unsigned first_flash;
854 const char * cfg_path = getenv(
"STXXLCFG");
863 for (
unsigned i = 0; i < disks_props.size(); ++i) {
864 if (disks_props[i].delete_on_exit) {
865 STXXL_ERRMSG(
"Removing disk file created from default configuration: " << disks_props[i].path);
866 unlink(disks_props[i].path.c_str());
871 void init(
const char * config_path =
"./.stxxl");
878 return disks_props.size();
885 return std::pair<unsigned, unsigned>(0, first_flash);
892 return std::pair<unsigned, unsigned>(first_flash, disks_props.size());
900 return disks_props[disk].path;
907 return disks_props[disk].size;
913 return disks_props[disk].io_impl;
921 virtual stxxl::file * create(
const std::string & io_impl,
922 const std::string & filename,
923 int options,
int disk);
925 virtual ~FileCreator() { }
938 int operator () (
int i)
const;
939 static const char * name();
947 striping(
int b,
int e) : begin(b), diff(e - b)
951 diff = config::get_instance()->disks_number();
953 int operator () (
int i)
const
955 return begin + i % diff;
957 static const char * name()
975 int operator () (
int )
const
977 return begin + rnd(diff);
979 static const char * name()
981 return "fully randomized striping";
999 int operator () (
int i)
const
1001 return begin + (i + offset) % diff;
1003 static const char * name()
1005 return "simple randomized striping";
1013 std::vector<int> perm;
1015 RC(
int b,
int e) :
striping(b, e), perm(diff)
1017 for (
int i = 0; i < diff; i++)
1020 stxxl::random_number<random_uniform_fast> rnd;
1025 for (
int i = 0; i < diff; i++)
1031 int operator () (
int i)
const
1033 return begin + perm[i % diff];
1035 static const char * name()
1037 return "randomized cycling striping";
1041 struct RC_disk :
public RC
1043 RC_disk(
int b,
int e) :
RC(b, e)
1045 RC_disk() :
RC(
config::get_instance()->regular_disk_range().first,
config::get_instance()->regular_disk_range().second)
1047 static const char * name()
1049 return "Randomized cycling striping on regular disks";
1053 struct RC_flash :
public RC
1055 RC_flash(
int b,
int e) :
RC(b, e)
1057 RC_flash() :
RC(
config::get_instance()->flash_range().first,
config::get_instance()->flash_range().second)
1059 static const char * name()
1061 return "Randomized cycling striping on flash devices";
1075 int operator () (
int )
const
1079 static const char * name()
1081 return "single disk";
1088 template <
class BaseAllocator_>
1091 BaseAllocator_ base;
1102 int operator () (int_type i)
const
1104 return base(offset + i);
1113 template <
class b
id_it>
1114 struct bid_iterator_traits
1119 block_size = bid_it::block_size
1123 template <
unsigned blk_sz>
1124 struct bid_iterator_traits<
BID<blk_sz> *>
1133 template <
unsigned blk_sz,
class X>
1134 struct bid_iterator_traits<__gnu_cxx::__normal_iterator<BID<blk_sz> *, X> >
1142 template <
unsigned blk_sz,
class X,
class Y>
1143 struct bid_iterator_traits<std::_List_iterator<BID<blk_sz>, X, Y> >
1151 template <
unsigned blk_sz,
class X>
1152 struct bid_iterator_traits<typename std::
vector<BID<blk_sz>, X>::iterator>
1168 friend class singleton<block_manager>;
1170 DiskAllocator ** disk_allocators;
1177 template <
class BIDType,
class DiskAssgnFunctor,
class BIDIteratorClass>
1178 void new_blocks_int(
1179 const unsigned_type nblocks,
1180 DiskAssgnFunctor functor,
1181 BIDIteratorClass out);
1192 template <
class DiskAssgnFunctor,
class BIDIteratorClass>
1194 DiskAssgnFunctor functor,
1195 BIDIteratorClass bidbegin,
1196 BIDIteratorClass bidend);
1206 template <
class BlockType,
class DiskAssgnFunctor,
class BIDIteratorClass>
1208 const unsigned_type nblocks,
1209 DiskAssgnFunctor functor,
1210 BIDIteratorClass out);
1218 template <
class BIDIteratorClass>
1219 void delete_blocks(
const BIDIteratorClass & bidbegin,
const BIDIteratorClass & bidend);
1223 template <
unsigned BLK_SIZE>
1230 template <
class BIDType,
class DiskAssgnFunctor,
class OutputIterator>
1231 void block_manager::new_blocks_int(
1232 const unsigned_type nblocks,
1233 DiskAssgnFunctor functor,
1236 typedef BIDType bid_type;
1237 typedef BIDArray<bid_type::t_size> bid_array_type;
1240 int_type * bl =
new int_type[ndisks];
1241 bid_array_type * disk_bids =
new bid_array_type[ndisks];
1242 file ** disk_ptrs =
new file *[nblocks];
1244 memset(bl, 0, ndisks *
sizeof(int_type));
1246 unsigned_type i = 0;
1248 for ( ; i < nblocks; ++i )
1250 const int disk = functor(i);
1251 disk_ptrs[i] = disk_files[disk];
1256 for (i = 0; i < ndisks; ++i)
1260 disk_bids[i].resize(bl[i]);
1261 const stxxl::int64 old_capacity =
1262 disk_allocators[i]->get_total_bytes();
1263 const stxxl::int64 new_capacity =
1264 disk_allocators[i]->new_blocks(disk_bids[i]);
1265 if (old_capacity != new_capacity)
1268 disk_files[i]->
set_size(new_capacity);
1269 if (new_capacity != disk_allocators[i]->get_total_bytes())
1270 STXXL_ERRMSG(
"File resizing failed: actual size " << disk_allocators[i]->get_total_bytes() <<
" != requested size " << new_capacity);
1275 memset(bl, 0, ndisks *
sizeof(int_type));
1277 OutputIterator it = out;
1278 for (i = 0 ; i != nblocks; ++it, ++i)
1282 const int disk = disk_ptrs[i]->get_id();
1283 bid_type bid(disk_ptrs[i], disk_bids[disk][bl[disk]++].offset);
1285 STXXL_VERBOSE_BLOCK_LIFE_CYCLE(
"BLC:new " << FMT_BID(bid));
1293 template <
class BlockType,
class DiskAssgnFunctor,
class OutputIterator>
1295 const unsigned_type nblocks,
1296 DiskAssgnFunctor functor,
1299 typedef typename BlockType::bid_type bid_type;
1300 new_blocks_int<bid_type>(nblocks, functor, out);
1303 template <
class DiskAssgnFunctor,
class BIDIteratorClass>
1305 DiskAssgnFunctor functor,
1306 BIDIteratorClass bidbegin,
1307 BIDIteratorClass bidend)
1309 typedef typename std::iterator_traits<BIDIteratorClass>::value_type bid_type;
1311 unsigned_type nblocks = 0;
1313 BIDIteratorClass bidbegin_copy(bidbegin);
1314 while (bidbegin_copy != bidend)
1320 new_blocks_int<bid_type>(nblocks, functor, bidbegin);
1324 template <
unsigned BLK_SIZE>
1327 STXXL_VERBOSE_BLOCK_LIFE_CYCLE(
"BLC:delete " << FMT_BID(bid));
1330 if (bid.
storage->get_id() == -1)
1332 assert(bid.
storage->get_id() >= 0);
1333 disk_allocators[bid.
storage->get_id()]->delete_block(bid);
1338 template <
class BIDIteratorClass>
1340 const BIDIteratorClass & bidbegin,
1341 const BIDIteratorClass & bidend)
1343 for (BIDIteratorClass it = bidbegin; it != bidend; it++)
1349 #ifndef STXXL_DEFAULT_ALLOC_STRATEGY
1350 #define STXXL_DEFAULT_ALLOC_STRATEGY stxxl::RC
1354 #ifndef STXXL_DEFAULT_BLOCK_SIZE
1355 #define STXXL_DEFAULT_BLOCK_SIZE(type) (2 * 1024 * 1024) // use traits
1360 __STXXL_END_NAMESPACE
1363 #endif // !STXXL_MNG_HEADER