S tos(O o){
S r,t;L z,i;switch(o->t){
case TD:r=alc(BZ)/*hope this is big enough!*/;sprintf(r,"%f",o->d);z=strlen(r)-1;while(r[z]=='0')r[z--]=0;if(r[z]=='.')r[z]=0;BK;
case TS:r=alc(o->s.z+1);memcpy(r,o->s.s,o->s.z);r[o->s.z]=0;BK;
case TA:r=alc(1);r[0]='[';z=1;for(i=0;i<len(o->a);++i){L l;if(i){r=rlc(r,z+1);r[z++]=',';}t=tos(o->a->st[i]);l=strlen(t);r=rlc(r,z+l);memcpy(r+z,t,l);z+=l;DL(t);}r=rlc(r,z+2);r[z]=']';r[z+1]=0;BK;
case TCB:r=alc(o->s.z+3);r[0]='{';memcpy(r+1,o->s.s,o->s.z);memcpy(r+1+o->s.z,"}",2);BK;
}R r;
} //tostring (copies)
int main(int argc, char** argv)
{
std::vector<ALshort> samples;
AL_Capture alc(MyAL::choisir_device(),MyAL::choisir_capture_device());
alc.start(samples);
std::chrono::milliseconds dura(1000);
std::this_thread::sleep_for(dura);
alc.stop();
if(argc<2)
alc.save_sound("test.wav");
else
alc.save_sound(argv[1]);
return EXIT_SUCCESS;
}
void emplace_back(Args&&... args)
{
auto new_node = NodeAllocatorTraits::allocate(alc_, 1);
try {
ValueAllocator alc(alc_);
ValueAllocatorTraits::construct(
alc, &new_node->t, std::forward<Args>(args)...
);
} catch(...)
{
NodeAllocatorTraits::deallocate(alc_, new_node, 1);
throw;
}
new_node->next = nullptr;
push_node(new_node);
}
/** Push object into the queue by moving it.
*
* @param t Object you want to push into the queue. Requires T to be
* MoveConstructible.
* @throws Any exceptions thrown by the move constructor of the object.
*
* @note This function is Thread-safe, lock-free and wait-free.
*/
void push_back(T&& t)
{
auto new_node = NodeAllocatorTraits::allocate(alc_, 1);
try {
ValueAllocator alc(alc_);
ValueAllocatorTraits::construct(
alc, &new_node->t, std::move(t)
);
} catch(...)
{
NodeAllocatorTraits::deallocate(alc_, new_node, 1);
throw;
}
new_node->next = nullptr;
push_node(new_node);
}
O newos(S s,L z){O r=newo();r->t=TS;r->s.s=alc(z+1);memcpy(r->s.s,s,z);r->s.s[z]=0;r->s.z=z;R r;} //new object string (copies)
O newocb(S s,L z){O r=newo();r->t=TCB;r->s.s=alc(z+1);memcpy(r->s.s,s,z);r->s.s[z]=0;r->s.z=z;R r;} //new object code block (copies)
O newo(){R alc(sizeof(OB));} //new object
ST newst(L z){ST s=alc(sizeof(STB));s->st=alc(z*sizeof(P));s->p=0;s->l=z;R s;} //new stack
S rdln(){L z;S r=alc(BZ);if(!fgets(r,BZ,stdin)){if(feof(stdin)){*r=0;R r;}else PXE;}z=strlen(r);if(r[z-1]=='\n')r[z-1]=0;if(z>1&&r[z-2]=='\r')r[z-2]=0;R r;} //read line(XXX:only allows BZ as max length!)
O low(O o){S r=alc(o->s.z+1);L i;for(i=0;i<o->s.z;++i)r[i]=tolower(o->s.s[i]);R newosk(r,o->s.z);} //lowercase
V rvx(ST s){S r;L z;O o=pop(s);if(o->t!=TS)TE;r=alc(o->s.z+1);for(z=0;z<o->s.z;++z)r[o->s.z-z-1]=o->s.s[z];dlo(o);psh(s,newosk(r,z));} //reverse object
O muls(O a,O b){S r,p;I i,t=b->d/*truncate*/;L z=a->s.z*t;p=r=alc(z+1);for(i=0;i<t;++i){memcpy(p,a->s.s,a->s.z);p+=a->s.z;}r[z]=0;R newosk(r,z);} //mul strings
O subs(O a,O b){L i,z=a->s.z;S r,p;if(b->s.z==0)R dup(a);for(i=0;i<a->s.z;++i)if(memcmp(a->s.s+i,b->s.s,b->s.z)==0)z-=b->s.z;p=r=alc(z+1);for(i=0;i<a->s.z;++i)if(memcmp(a->s.s+i,b->s.s,b->s.z)==0)i+=b->s.z-1;else*p++=a->s.s[i];R newosk(r,z);} //sub strings
O adds(O a,O b){S rs=alc(a->s.z+b->s.z+1);memcpy(rs,a->s.s,a->s.z);memcpy(rs+a->s.z,b->s.s,b->s.z+1);R newosk(rs,a->s.z+b->s.z);} //add strings
// テストの実行!
double doTestImpl(int testNum, int sequence) override {
currentTestNum_ = testNum;
const size_t bufferSize = 1024*1024*256; // 256M
BaseAllocator alc(bufferSize);
TsAllocator::defaultAllocator_ = &alc;
double ret = 0;
BoostContainerAnalayzer bca;
StlContainerAnalayzer sca;
switch (testCase_) {
case SO_ALLOCATOR2_TEST: // 301
case LO_ALLOCATOR2_TEST:
{ // 302
std::function<double(int, size_t)> tb[] = {
[&](int sequence, size_t loops) { return test_push_back<std::vector<ElementType> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return test_push_back<std::vector<ElementType, MyAllocator> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return test_push_back<boost::container::vector<ElementType>>(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_push_back<boost::container::vector<ElementType, MyAllocator> >(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_push_back<boost::container::vector<ElementType, boost::container::allocator<ElementType, 1>>>(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_push_back<boost::container::vector<ElementType, boost::container::allocator<ElementType, 2>>>(sequence, loops, bca); }
};
ret = tb[testNum - 1](sequence, LOOPS);
}
break;
case SO_ALLOCATOR2_UNITTIME: // 303
case LO_ALLOCATOR2_UNITTIME: // 304
{
if (sequence == 1) {
std::memset(&unittimes_[0], 0, sizeof(unittimes_));
if (testNum == 1) {
ofs_.open(std::string(testTable[testCase_].name_) + ".csv");
}
}
std::function<double(int, size_t)> tb[] = {
[&](int sequence, size_t loops) { return push_back_unittime<std::vector<ElementType> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return push_back_unittime<std::vector<ElementType, MyAllocator> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return push_back_unittime<boost::container::vector<ElementType>>(sequence, loops, bca); },
[&](int sequence, size_t loops) { return push_back_unittime<boost::container::vector<ElementType, MyAllocator> >(sequence, loops, bca); },
[&](int sequence, size_t loops) { return push_back_unittime<boost::container::vector<ElementType, boost::container::allocator<ElementType, 1>>>(sequence, loops, bca); },
[&](int sequence, size_t loops) {
return push_back_unittime<boost::container::vector<ElementType, boost::container::allocator<ElementType, 2>>>(sequence, loops, bca); },
};
ret = tb[testNum - 1](sequence, LOOPS);
if (sequence == TestMain::TestSequenceCount_) {
outputUnitTime(ofs_, testNum, ElementSize);
}
}
break;
case SO_ALLOCATOR2_INSERT: // 305
case LO_ALLOCATOR2_INSERT: // 306
{
if (sequence == 1) {
std::memset(&unittimes_[0], 0, sizeof(unittimes_));
if (testNum == 1) {
ofs_.open(std::string(testTable[testCase_].name_) + ".csv");
}
}
std::function<double(int, size_t)> tb[] = {
[&](int sequence, size_t loops) { return test_insert<std::vector<ElementType> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return test_insert<std::vector<ElementType, MyAllocator> >(sequence, loops, sca); },
[&](int sequence, size_t loops) { return test_insert<boost::container::vector<ElementType>>(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_insert<boost::container::vector<ElementType, MyAllocator> >(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_insert<boost::container::vector<ElementType, boost::container::allocator<ElementType, 1>>>(sequence, loops, bca); },
[&](int sequence, size_t loops) { return test_insert<boost::container::vector<ElementType, boost::container::allocator<ElementType, 2>>>(sequence, loops, bca); },
};
ret = tb[testNum - 1](sequence, LOOPS);
if (sequence == TestMain::TestSequenceCount_) {
outputUnitTime(ofs_, testNum, NumContainers);
}
}
break;
default:
break;
}
if (sequence == 1) {
if (alc.total_alloc_bytes_) {
outputMessage(str(format("allocator: memory leak! %u" ENDL) % alc.total_alloc_bytes_));
}
}
return ret;
}
