1 Jul 2010 07:12
The effect of cache on performance
Richard <legalize <at> xmission.com>
2010-07-01 05:12:11 GMT
2010-07-01 05:12:11 GMT
I stumbled across this today and found it an interesting read. <http://queue.acm.org/detail.cfm?id=1814327> It relates to our "virtual function calls are bad!"[*] discussion earlier. [*] they're not really bad, its cache misses that are bad. -- -- "The Direct3D Graphics Pipeline" -- DirectX 9 draft available for download <http://legalizeadulthood.wordpress.com/the-direct3d-graphics-pipeline/> Legalize Adulthood! <http://legalizeadulthood.wordpress.com> _______________________________________________ Sweng-Gamedev mailing list Sweng-Gamedev <at> lists.midnightryder.com http://lists.midnightryder.com/listinfo.cgi/sweng-gamedev-midnightryder.com
> Anyway, the example you had (PFC_MONO()) doesn't actually add all the
> annotations you want for editing and serialization in addition to the
> general reflection information.
> You can get rid of the ellipsis requirement by doing something like:
> #define MEMBERS(Type, x) \
> typedef mytype Type; \
> inline static Member *GetMembers() { \
> static Member<mytype>[] members = { \
> x \
> }; \
> return x; \
> }
> #define MEMBER(x, desc) Member<mytype>(&mytype::x, #x, desc),
> Use it like so:
> struct MyStruct {
> int x;
> float b;
> MEMBERS(MyStruct,
> MEMBER(x, "Some integer value")
> MEMBER(b, "The amount of float-ness"))
> };
> Note that the comma lives in the MEMBER() macro, and the members are
> just listed without comma within the MEMBERS() macro. The MEMBER()
> macro should take the union of all information you need about the
> member (editor information, networking, etc).
Still seems like it has a lot of oddity in its syntax, what about
something like this, which is completely possible and rather easily
done actually:
class Foo
{
public:
Foo() {}
virtual ~Foo() {}
private:
DefineClass(Foo); // Why not make this define the actual class in
its entirety?
Member((type(int))(name(test))(default(0))(description("Some int"));
Member((type(char*))(name(mName))(default("foo"))(description("Some
static text"))(serialized));
Member((type(int*))(name(mBuffer))(default(NULL))(description("Some
ptr to nowhere"))(serialized);
Member((type(int))(name(foo)));
Member((type(int))(name(foo2))(description("this one has a desc,
unlike foo")));
Member((type(int))(name(foo3))(default(0xDead)));
EndClass();
};
That style lets you add new capabilities arbitrarily without
introducing new Member overloads or what-not, just adding a keyword,
simple to do. Or if you want to use the Boost proposed Mirror C++
reflection library, it would be this (this is non-intrusive for note):
class Foo
{
public:
Foo() {}
virtual ~Foo() {}
int test;
char *mName;
int *mBuffer;
int foo;
int foo2;
int get_foo3() const;
void set_foo3(const int i);
float someFunc(int);
private:
int foo3;
};
BOOST_MIRROR_REG_BEGIN
BOOST_MIRROR_REG_CLASS_GLOBAL_SCOPE_BEGIN(class, foo)
BOOST_MIRROR_REG_CLASS_MEM_VARS_BEGIN
BOOST_MIRROR_REG_CLASS_MEM_VAR(public, _, _, test)
BOOST_MIRROR_REG_CLASS_MEM_VAR(public, _, _, mName)
BOOST_MIRROR_REG_CLASS_MEM_VAR(public, _, _, mBuffer)
BOOST_MIRROR_REG_CLASS_MEM_VAR(public, _, _, foo)
BOOST_MIRROR_REG_CLASS_MEM_VAR(public, _, _, foo2)
BOOST_MIRROR_REG_CLASS_MEM_VAR_GET_SET(
private,
_, int, foo3,
_.get_foo3(),
_.set_foo3(_a)
)
BOOST_MIRROR_REG_CLASS_MEM_VARS_END
float someFunc(int);
BOOST_MIRROR_REG_MEM_FUNCTION_BEGIN(public, _, float, someFunc, someFuncI)
BOOST_MIRROR_REG_MEM_FUNCTION_PARAM(int, i)
BOOST_MIRROR_REG_MEM_FUNCTION_END(someFunc, someFuncI)
BOOST_MIRROR_REG_CLASS_END
And it has things to handle type conversions supported and much more.
The docs are at: 
RSS Feed