Bitový posun celého pole

Zdravím.

Potřebuji poradit, jak provést bitový posun celého pole s co nejmenší náročností na čas.
Mé výtvory jsou poněkud hrubé a náročné na čas.

Představuji si totakto:

unsigned char MePole[5]={0x81,0x81,0x81,0x81,0x81};

Po bitovém posunu 0 1 vlevo by mělo v poli být {0x03,0x03,0x03,0x03,0x02}.

Pole však může v mé aplikaci nabývat i větších rozměru.
Předem děkuji za případnou radu.

V C to vyjde dost neefektivně:

#define POLEN 5 unsigned char* p = &MePole[POLEN-1]; unsigned char b; unsigned char carry = 0; for (i = POLEN; i > 0; i--) { b = *p; *p++ = (b << 1) | carry; carry = (b >> 7); }
V assembleru to bude mnohem efektivnější - použije se instrukce ROL, která narotuje bajt o 1 bit vlevo a k přenosu použije carry bit, který se uchová pro následující bajt. Navíc se dá optimalizovat cyklus tak, že se provede několik rotací naráz (rotuje se po větších úsecích pole, např. po 10)…

clc loop: ld temp,-x rol temp st -y,temp dec citac brne loop

#include <common.h>

unsigned char MePole[5]={0x81,0x81,0x81,0x81,0x81};

int main(void)
{
  unsigned int i;
  unsigned char StatusReg;

  StatusReg=SREG;
  StatusReg&=~(1<<SREG_C);

  for (i=0 ; i<sizeof(MePole) ; i++)
  {

    SREG=StatusReg;
    MePole[sizeof(MePole)-1-i]=(StatusReg&(1<<SREG_C))?(MePole[sizeof(MePole)-1-i]<<1)+1:(MePole[sizeof(MePole)-1-i]<<1);
    StatusReg=SREG;

  }  
  asm volatile ("nop");  // A je hotovo - nop je tu jenom kvůli tomu, aby bylo kam dát breakpoint.
}

Ten Pandovo ASM kód není správně, každopádně má pravdu v tom, že v ASM je to daleko jednodušší a efektivnější.

Takhle to vypadá v ASM :

#include <m8def.inc>

#define DelkaPole 5

.def Temp=R16
.def Citac=R17
.def StatusRegistr=R0

.dseg
MojePole: .byte DelkaPole

.cseg
.org 0
// --------------------- Inicializace pole (tohle za Tebe udělá překladač deklarací pole) ---------------------
	ldi Temp, 0x81
	ldi XH, high(MojePole)
	ldi XL, low(MojePole)
	ldi Citac, DelkaPole
Inicializace_pole:
	st X+, Temp
	dec Citac
	brne Inicializace_pole


// --------------------- Tady už je vlastní rotace polem ---------------------

	ldi XH, high(MojePole+DelkaPole)
	ldi XL, low(MojePole+DelkaPole)
	ldi Citac, DelkaPole

	clc
	in StatusRegistr, SREG

Rotuj:
	out SREG, StatusRegistr
	ld Temp, -X
	rol Temp
	st X, Temp
	in StatusRegistr, SREG
	dec Citac
	brne Rotuj

Konec: rjmp Konec  // A je hotovo

Rozdíl v délce kódu pro 5 položek je :
ASM - 40 bytů
C - 150 bytů

Rychlosti pro 5 položek :
ASM - 13,50us
C - 32,00us

Rozdíl v délce kódu pro 100 položek je :
ASM - 40 bytů
C - 242 bytů

Rychlosti pro 100 položek :
ASM - 251,00us
C - 625,75us

Délka kódu by se i u ASM změnila, kdyby nebyly všechny hodnoty stejné a pole by se kopírovalo z programový paměti do RAM. Rychlosti jsou měřené v simulátoru pro ATmega8 na IntRC 4 MHz a kvůli poměření efektivity kódu pro rotaci v nich není započítána inicializace polí, protože ta se provádí pouze 1x při startu, kdežto rotace polem může být volána v nějakých pravidelných intervalech.

Oba kódy jsou odzkoušeny.

Balů proč v ASM uchováváš SREG do proměnné? Instrukce DEC nemění carry flag, jestli to děláš kvůli tomu, je to nadbytečné.

Více operací najednou pro větší rychlost - podmínka že velikost pole > 4 a nesmí být násobek 4 (jasně že se to dá snadno ošetřit, třeba i podmíněným překladem):

[code] ldi Citac, DelkaPole/4
clc

Rotuj:
ld Temp, -X
rol Temp
st X, Temp

ld Temp, -X
rol Temp
st X, Temp

ld Temp, -X
rol Temp
st X, Temp

ld Temp, -X
rol Temp
st X, Temp

dec Citac
brne Rotuj

#if ((DelkaPole & 3) == 0)
ldi Citac, DelkaPole & 3

Rotuj2:
ld Temp, -X
rol Temp
st X, Temp

dec Citac
brne Rotuj2
#endif
[/code]

Máš pravdu. Carry flag to neovlivní nějak mě zblblo to Céčko:

#include <m8def.inc>

#define DelkaPole 5 // max. 256 bytů

.def Temp=R16
.def Citac=R17
.def StatusRegistr=R0

.dseg
MojePole: .byte DelkaPole

.cseg
.org 0
	ldi Temp, 0x81
	ldi XH, high(MojePole)
	ldi XL, low(MojePole)
	ldi Citac, low(DelkaPole)
Inicializace_pole:
	st X+, Temp
	dec Citac
	brne Inicializace_pole

	ldi XH, high(MojePole+DelkaPole)
	ldi XL, low(MojePole+DelkaPole)
	ldi Citac, low(DelkaPole)

	clc

Rotuj:
	ld Temp, -X
	rol Temp
	st X, Temp
	dec Citac
	brne Rotuj

Konec: rjmp Konec // A hotovo

Nicméně ještě jsem program upravil pro použití s polem až do 65536 bytů a tam už úschova SREG nutná je :

#include <m8def.inc>

#define DelkaPole 1024 // max. 65536 nebo velikost SRAM
// nezapomenout nechat také rezervu pro ostatní proměnné a zásobník

.def Temp=R16
.def StatusRegistr=R0

.dseg
MojePole: .byte DelkaPole

.cseg
.org 0
	ldi Temp, 0x81
	ldi XH, high(MojePole)
	ldi XL, low(MojePole)
	ldi YH, high(DelkaPole)
	ldi YL, low(DelkaPole)
Inicializace_pole:
	st X+, Temp
	sbiw YH:YL, 1
	brne Inicializace_pole

	ldi XH, high(MojePole+DelkaPole)
	ldi XL, low(MojePole+DelkaPole)
	ldi YH, high(DelkaPole)
	ldi YL, low(DelkaPole)

	clc
	in StatusRegistr, SREG

Rotuj:
	out SREG, StatusRegistr
	ld Temp, -X
	rol Temp
	st X, Temp
	in StatusRegistr, SREG
	sbiw YH:YL, 1
	brne Rotuj

Konec: rjmp Konec

Nebo rychlejší modifikace pro větší pole:

ldi YH, high(DelkaPole+255) ldi YL, low(DelkaPole) clc Rotuj: ld Temp, -X rol Temp st X, Temp dec YL brne Rotuj dec YH brne Rotuj

Děkuji všem za odpovědi.