«

I am thinking about using this technique for all the "local" memory pools in
a paticular multi-threaded allocator algorithm I invented. Some more info on
that can be found here:

http://groups.google.com/group/comp....c40d42a04ee855

Anyway, here is the code snippet:

#include <cstdio>
#include <cstddef>
#include <new>


template<size_t T_sz>
class lmem {
unsigned char m_buf[T_sz];
public:
void* loadptr() {
return m_buf;
}
};


class foo {
public:
foo() { printf("(%p)foo::~foo()", (void*)this); }
~foo() { printf("(%p)foo::~foo()", (void*)this); }
};


int main(void) {
foo *f;
lmem<sizeof(*f)> foomem;
f = new (foomem.loadptr()) foo;
f->~foo();
return 0;
}

Chris Thomasson wrote:
> I am thinking about using this technique for all the "local" memory
> pools in a paticular multi-threaded allocator algorithm I invented.
> Some more info on that can be found here:
>
> http://groups.google.com/group/comp....c40d42a04ee855
>
> Anyway, here is the code snippet:
>
> #include <cstdio>
> #include <cstddef>
> #include <new>
>
>
> template<size_t T_sz>
> class lmem {
> unsigned char m_buf[T_sz];
> public:
> void* loadptr() {
> return m_buf;
> }
> };
>
>
> class foo {
> public:
> foo() { printf("(%p)foo::~foo()", (void*)this); }

The string seems to be incorrect.

> ~foo() { printf("(%p)foo::~foo()", (void*)this); }
> };
>
>
> int main(void) {
> foo *f;
> lmem<sizeof(*f)> foomem;
> f = new (foomem.loadptr()) foo;

It's not "incorrect", but I believe you may have a problem
with alignment. Only a memory block sized 'sizeof(foo)'
obtained from free store is aligned correctly to have a 'foo'
constructed in it like that.

> f->~foo();
> return 0;
> }

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Chris Thomasson wrote:
> I am thinking about using this technique for all the "local" memory pools in
> a paticular multi-threaded allocator algorithm I invented. Some more info on
> that can be found here:
>
> http://groups.google.com/group/comp....c40d42a04ee855
>
> Anyway, here is the code snippet:
>
> #include <cstdio>
> #include <cstddef>
> #include <new>
>
>
> template<size_t T_sz>
> class lmem {
> unsigned char m_buf[T_sz];

You may run into alignment problems by using an array of unsigned char,
you should follow the same system specific alignment rules as malloc.

> public:
> void* loadptr() {
> return m_buf;
> }
> };
>
>
> class foo {
> public:
> foo() { printf("(%p)foo::~foo()", (void*)this); }
> ~foo() { printf("(%p)foo::~foo()", (void*)this); }
> };
>
C++ purists avoid printf. Never mix it with iostreams.
>
> int main(void) {

Just int main() is the norm in C++.

--
Ian Collins.

Ian Collins wrote:


> C++ purists avoid printf. Never mix it with iostreams.

Bah. Pointlessly dogmatic. Sometimes it's the right thing.




Brian

Default User wrote:
> Ian Collins wrote:
>
>>C++ purists avoid printf. Never mix it with iostreams.
>
> Bah. Pointlessly dogmatic. Sometimes it's the right thing.
>
Care to cite an example?

--
Ian Collins.

On 27 Feb, 22:59, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
> Chris Thomasson wrote:
> > I am thinking about using this technique for all the "local" memory
> > pools in a paticular multi-threaded allocator algorithm I invented.
> > Some more info on that can be found here:
>
> >http://groups.google.com/group/comp....ead/24c40d42a0...
>
> > Anyway, here is the code snippet:
>
> > #include <cstdio>
> > #include <cstddef>
> > #include <new>
>
> > template<size_t T_sz>
> > class lmem {
> > unsigned char m_buf[T_sz];
> > public:
> > void* loadptr() {
> > return m_buf;
> > }
> > };
>
> > class foo {
> > public:
> > foo() { printf("(%p)foo::~foo()", (void*)this); }
>
> The string seems to be incorrect.
>
> > ~foo() { printf("(%p)foo::~foo()", (void*)this); }
> > };
>
> > int main(void) {
> > foo *f;
> > lmem<sizeof(*f)> foomem;
> > f = new (foomem.loadptr()) foo;
>
> It's not "incorrect", but I believe you may have a problem
> with alignment. Only a memory block sized 'sizeof(foo)'
> obtained from free store is aligned correctly to have a 'foo'
> constructed in it like that.
>

IMO, because the array is wrapped in a class there shouldnt be a
problem. IOW thc class alignment will take care of the issue. However
It should be possible to check . (Not absolutely sure if this is the
correct solution but whatever ...

regards
Andy Little

#include <stdexcept>

// aka std::tr1::
template <typename T>
struct alignment_of{
#if defined _MSC_VER
static const unsigned int value = __alignof(T);
#elif defined __GNUC__
static const unsigned int value = __alignof__(T);
#else
#error need to define system dependent align_of
#endif
};


template<typename T, size_t T_sz>
class lmem {

unsigned char m_buf[T_sz];
public:
void* loadptr() {
// check its aligned correctly
ptrdiff_t dummy = m_buf - static_cast<char*>(0);
ptrdiff_t offset = dummy % alignment_of<T>::value;
if(!offset)
return m_buf;
throw std::logic_error("lmem memory doesnt satisfy alignment");
}
};


int main()
{
typedef double type;
lmem<type,sizeof(type)> x;
}

On 28 Feb, 01:25, "kwikius" <a...@servocomm.freeserve.co.uk> wrote:

> IMO, because the array is wrapped in a class there shouldnt be a
> problem. IOW thc class alignment will take care of the issue.

Well I was wrong about that :.
(Back to the drawing board I guess)

But at least the code seems to detect the problem :

#include <stdexcept>

// aka std::tr1::
template <typename T>
struct alignment_of{
#if defined _MSC_VER
static const unsigned int value = __alignof (T);
#elif defined __GNUC__
static const unsigned int value = __alignof__(T);
#else
#error need to define system dependent align_of
#endif
};


template<typename T, size_t T_sz>
class lmem {

unsigned char m_buf[T_sz];
public:
void* loadptr() {
// check its aligned correctly
ptrdiff_t dummy = m_buf - static_cast<unsigned char*>(0);
ptrdiff_t offset = dummy % alignment_of<T>::value;
if(!offset)
return m_buf;
throw std::logic_error("lmem memory doesnt staisfy alignment");
}
};

#include <iostream>
int main()
{
try{
typedef double type;
char c;
lmem<type,sizeof(type)> x;
void * p = x.loadptr() ;
}
catch(std::exception & e)
{
std::cout << e.what() <<'\n';
}
}
/* output:
lmem memory doesnt staisfy alignment

*/
regards
Andy Little

kwikius wrote:
>
> IMO, because the array is wrapped in a class there shouldnt be a
> problem. IOW thc class alignment will take care of the issue. However
> It should be possible to check . (Not absolutely sure if this is the
> correct solution but whatever ...
>
No, the class may be aligned according to the alignment requirements of
its members, in this case unsigned char.

--
Ian Collins.

On 28 Feb, 02:47, Ian Collins <ian-n...@hotmail.com> wrote:
> kwikius wrote:
>
> > IMO, because the array is wrapped in a class there shouldnt be a
> > problem. IOW thc class alignment will take care of the issue. However
> > It should be possible to check . (Not absolutely sure if this is the
> > correct solution but whatever ...
>
> No, the class may be aligned according to the alignment requirements of
> its members, in this case unsigned char.

Yep. I figured it out eventaully I think.
It seems to be possible but at the expense of always allocating your
char array oversize by alignment_of<T> -1. Its not possible to know
where on the stack the lmem object will go.

Anyway the following seems to work :


template<typename T, size_t T_sz>
class lmem {
// Don't think there is a way to avoid
// allocating extra stack space ...
unsigned char m_buf[T_sz + alignment_of<T>::value -1];
public:
void* loadptr() {
// align memory to T
ptrdiff_t dummy = m_buf - static_cast<unsigned char*>(0);
ptrdiff_t offset = dummy % alignment_of<T>::value;
ptrdiff_t result = offset == 0
? dummy
: dummy + alignment_of<T>::value - offset;
// check this works
assert( result % alignment_of<T>::value == 0);
return static_cast<unsigned char*>(0) + result;
}
};

struct my{
int x, y;
double z;
my(int xx, int yy, double zz): x(xx),y(yy),z(zz){}
};

#include <iostream>
int main()
{

// muck about with stack offsets
char c = '\n';
short n = 1;
lmem<double,sizeof(double)> x;
double * pd = new (x.loadptr()) double(1234.56789);
std::cout << *pd <<'\n';

lmem<my, sizeof(my)> y;
my * pc = new (y.loadptr()) my(1,2,3);

std::cout << pc->x << ' ' << pc->y << ' ' << pc->z <<'\n';

}

regards
Andy Little


>
> --
> Ian Collins.

kwikius wrote:
> On 28 Feb, 02:47, Ian Collins <ian-n...@hotmail.com> wrote:
>
>>kwikius wrote:
>>
>>
>>>IMO, because the array is wrapped in a class there shouldnt be a
>>>problem. IOW thc class alignment will take care of the issue. However
>>>It should be possible to check . (Not absolutely sure if this is the
>>>correct solution but whatever ...
>>
>>No, the class may be aligned according to the alignment requirements of
>>its members, in this case unsigned char.
>
>
> Yep. I figured it out eventaully I think.
> It seems to be possible but at the expense of always allocating your
> char array oversize by alignment_of<T> -1. Its not possible to know
> where on the stack the lmem object will go.
>
> Anyway the following seems to work :
>
>
> template<typename T, size_t T_sz>
> class lmem {
> // Don't think there is a way to avoid
> // allocating extra stack space ...
> unsigned char m_buf[T_sz + alignment_of<T>::value -1];
> public:
> void* loadptr() {
> // align memory to T
> ptrdiff_t dummy = m_buf - static_cast<unsigned char*>(0);
> ptrdiff_t offset = dummy % alignment_of<T>::value;
> ptrdiff_t result = offset == 0
> ? dummy
> : dummy + alignment_of<T>::value - offset;
> // check this works
> assert( result % alignment_of<T>::value == 0);
> return static_cast<unsigned char*>(0) + result;
> }
> };
>
Or even:

template <typename T>
class lmem {
T t;
public:
void* loadptr() {
return &t;
}
};


--
Ian Collins.