Von der Zugriffszeit tun sich SRAM und Flash nicht viel, was etwas teurer sein kann ist die Adressberechnung und weil der Flash nur via Z-Reg gelesen werden kann.

Um aus dem Flash ein Byte zu lesen gibt es in avr/pgmspace.h das Makro
pgm_read_byte (addr)
in dem addr ein C-Ausdruck ist, der zu einer Adresse auswertet (bzw. unsigned int).
Beim Zugriff auf zwei aufeinanderfolgende Adressen muss die Adresse immer wieder neu berechnet werden. Ist die Adresse jedoch ein Lvalue, könnte sie im Z gehalten werden und der Zugriff dementsprechend effizienter gestaltet werden.

Code:
#include <avr/pgmspace.h>

#if defined (__AVR_ENHANCED__)

#define pgm_read_byte_inc(addr)             \
({                                          \
    uint8_t __result;                       \
    __asm__                                 \
    (                                       \
        "lpm %0, Z+"                        \
        : "=r" (__result), "=z" (addr)      \
        : "1" (addr)                        \
    );                                      \
    __result;                               \
})
#endif /* __AVR_ENHANCED__ */

uint8_t sram[7];
const uint8_t flash[10][7] PROGMEM = 
{
};

void foo (uint8_t num)
{
	uint8_t i;
	
	for (i=0; i<7; i++)
		sram[i] = pgm_read_byte (& flash[num][i]);
}

void foo2 (uint8_t num)
{
	uint8_t i;
	
	const void * addr = flash[num];
	
	for (i=0; i<7; i++)
		sram[i] = pgm_read_byte_inc (addr);
}

void foo3 (uint8_t num)
{
	const void * addr = flash[num];

	sram[0] = pgm_read_byte_inc (addr);
	sram[1] = pgm_read_byte_inc (addr);
	sram[2] = pgm_read_byte_inc (addr);
	sram[3] = pgm_read_byte_inc (addr);
	sram[4] = pgm_read_byte_inc (addr);
	sram[5] = pgm_read_byte_inc (addr);
	sram[6] = pgm_read_byte_inc (addr);
}
Ja kannst du dann wählen, was du haben willst: minimale Laufzeit oder kleinster Code:
Code:
.global	flash
	.section	.progmem.data,"a",@progbits
	.size	flash, 70
flash:
	.skip 70,0
/*************************************************/	
.text
.global	foo
foo:
	ldi r25,lo8(7)	 ;  tmp48,
	mul r24,r25	 ;  num, tmp48
	movw r30,r0	 ;  tmp54
	clr r1
	ldi r26,lo8(sram)	 ;  tmp53,
	ldi r27,hi8(sram)	 ;  tmp53,
	subi r30,lo8(-(flash))	 ;  tmp54,
	sbci r31,hi8(-(flash))	 ;  tmp54,
	ldi r25,lo8(6)	 ;  i,
.L161:
	lpm r24, Z	 ;  __result
	st X+,r24	 ;  sram, __result
	subi r25,lo8(-(-1))	 ;  i,
	adiw r30,1	 ;  tmp54,
	sbrs r25,7	 ;  i,
	rjmp .L161	 ; 
	ret
/*************************************************/	
.global	foo2
foo2:
	ldi r25,lo8(7)	 ;  tmp45,
	mul r24,r25	 ;  num, tmp45
	movw r30,r0	 ;  addr
	clr r1
	subi r30,lo8(-(flash))	 ;  addr,
	sbci r31,hi8(-(flash))	 ;  addr,
	ldi r26,lo8(sram)	 ;  tmp51,
	ldi r27,hi8(sram)	 ;  tmp51,
	ldi r25,lo8(6)	 ;  i,
.L168:
	lpm r24, Z+	 ;  __result
	st X+,r24	 ;  sram, __result
	subi r25,lo8(-(-1))	 ;  i,
	sbrs r25,7	 ;  i,
	rjmp .L168	 ; 
	ret
/*************************************************/	
.global	foo3
foo3:
	ldi r25,lo8(7)	 ;  tmp45,
	mul r24,r25	 ;  num, tmp45
	movw r30,r0	 ;  addr
	clr r1
	subi r30,lo8(-(flash))	 ;  addr,
	sbci r31,hi8(-(flash))	 ;  addr,
	lpm r24, Z+	 ;  __result
	sts sram,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+1,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+2,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+3,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+4,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+5,r24	 ;  sram, __result
	lpm r24, Z+	 ;  __result
	sts sram+6,r24	 ;  sram, __result
	ret
/*************************************************/	
sram:
	.skip 7,0