I would declare and use a constant vector array.
It depends on what is important about how the addresses are generated.
Are they necessarily in increments of one, skipping every 4th one, or
is that just a coincidence? For something simple (few resources, and
shouldn't take much time), think about coding it such that the
requirements are most clear. If they are supposed to increment, code
an adder with some skip logic. If they are (or could be) arbitrary,
Mike's suggestion of a constant lookup table is excellent. A good
synthesis tool would probably implement the same circuit with either
description for something this small. If not, a constant lookup table
can be initialized via a function that illustrates the algorithm. That
way, you get the illustrative benefits of an algorithm, with the
resource/performance benefits of a look-up table. Another advantage of
an algorithm is that it can usually be expanded easily if more
addresses are needed in the same pattern.
Also, depending on your application, it is sometimes easier to mask
off unused addresses such that nothing happens when they are accessed
(i.e. AND the data being stored with a constant mask that is set to
zeroes for the unused addresses, and apply the same mask when reading
the registers), rather than going to the trouble to avoid them. If
properly done, the masking will result in the resources for those
unused addresses being optimized away.
Andy
