Re: Language Efficiency

[graham@compass-da.com (Paul Graham)]

Here's an example of language-based inefficiency.  Suppose I want to allocate
a structure and initialize its fields to some safe value, say 0.  In C I
would write

	ptr = malloc(sizeof(struct_type));
	memset(ptr, '\0', sizeof(struct_type));

In Ada I would write

	ptr := new struct_type'(others => 0);

or

	ptr := new struct_type;		-- assuming I want the default values

The call to memset in the C example can be quite inefficient.  memset does
not know that ptr is a word-aligned address, so it must fill in the
structure using byte moves.  I suppose memset could be clever and check for
the alignment of ptr and the value of sizeof(struct_type), and jump to an
appropriate loop which uses byte moves, word moves, longword moves, etc.

The Ada code should know that ptr will be word-aligned.  Assuming that it
doesn't first create a temporary aggregate, it should be able to fill in
ptr's fields efficiently using word moves.

I could achieve the same effect in C by writing

	ptr = malloc(sizeof(struct_type));
	ptr->x = 0;
	ptr->y = 0;
	...

but this style of initialization breaks easily if I ever add a new field to
struct_type.

Paul
--
Paul Graham 	graham@compass-da.com	Compass Design Automation, Inc.
(speaking only for myself)	"Cekoslovakyalilastiramadiklarimizdanmissiniz."