byte algin - denkproblem

[CMatt]

hi leute,
ich brauch mal wieder ne denkanstoß von euch bit-freaks
Hier mal ne kurze beschreibung meines Problems:
Ich habe 2 Spiecherblocks, eine Quelle und Ziel und nen code der aus der Quelle liest und gewisse daten parst. Einige dieser Daten werden 1:1 wieder in ins Ziel kopiert, einige werden durch andere ersetzt. Kling ziehmlich einfach.. ist es auch würde das ganze nicht auf Bitbasis funktioniern
Zur Zeit lese ich Bitweise aus der Quelle und schreibe das Zeug wieder Bitweise in das Ziel. Läuft auch bestens mit nem kleinen Hacken, es handelt sich bei den Datenmengen um x GB und das Bitweise zu schreiben dauert mir zu lang..
Was ich nun versuche ist beide Blöcke auf nen Byteanfang zu alginen und so nen großen block byteweise zu kopieren. Da aber zur Zeit mein kopf voll mit nullen und einsen ist schaff ich es nicht

Das Ganze läuft so ab:
Der Parser ließt aus aus der Quelle. Sollen die werte 1:1 kopiert werden wir eine counter inkrementiert. Soblad Daten kommen die ersetzt werden sollen, werden so viele Bits wieder counter anzeigt in das Ziel kopiert und die neuen Daten hinterher. Wie schaffe ich nun dieses Kopieren von Quelle zu Ziel so schnell wie möglich zu machen?

Da hängt es:
- Von der Quelle sollen ab Byte 1, Bit 3, 270 Bits ins Ziel kopiert werden.
- Der Zielpointer steht zur Zeit auf Byte 1, Bit 4.
Muss ich nun wirklich 270 bits bitweise ins Ziel kopieren nur weil das offset um 1 bit verschoben ist? kann nicht sein...

Wie gesagt... ich hab zur Zeit ein Brett vrom Kopf.. womöglich kann es mir einer von euch entfernen.

btw. Das ganze steht im assmebler forum, da guter alter asm-code immer noch am schnellst läuft und die Leute hier am ehen bitweise denekn können

[Nobuo T]

Hy.

Voellig ohne Bit-Basteleien pro eingelesenem byte wirst du IMHO nicht umher kommen.

Habe mal versucht, das ganze etwas ausfuehrlicher zu illustrieren:

Legende:
x steht fuer irgend welche "unwichtigen Bits"
Q sind die Quellbits
Z sind bereits im Zielarray befindliche Bits

Es muessen beim Kopieren 3 Faelle unterschieden werden:
1.Quellbit>Zielbit: Rechtsshift um Bitdifferenz, um Quelle anzupassen
2.Zielbit>Quellbit: Linksshift um Bitdifferenz, um Quelle anzupassen
3.Quellbit=Zielbit: Einfachster Fall

In den 2 Beispielen wird jeweils ein Word aus dem Quellarray gelesen.
Nach jedem Kopiervorgang, wie gehabt Quell-/Ziel-pointer um 1
incrementieren und Kopierroutine noch mal von vorn durchlaufen.

Bsp. zu Fall 1:
QuellBit=5
ZielBit=1
xxxQ QQQQ QQQx xxxx
0000 0000 0000 000Z

Quelle dann shr BitDifferenz (4):
0000 xxxQ QQQQ QQQx

und and (00FF shl ZielBit) => and 01FE:
0000 000Q QQQQ QQQ0

Ziel or Quelle:
0000 000Q QQQQ QQQZ

Zu Fall 2:
QuellBit=2
ZielBit=5
xxxx xxQQ QQQQ QQxx
0000 0000 000Z ZZZZ

Das dann shl BitDifferenz (3):
xxxQ QQQQ QQQx x000

and (00FF shl ZBitPointer) => and 1FE0:
000Q QQQQ QQQ0 0000

Ziel or Quelle:
000Q QQQQ QQQZ ZZZZ

Bei Fall 3 brauchts den ganzen Zauber nicht, da kann nach den ersten paar bits einfach byteweise kopiert werden.

Auch wenn das jetzt zu doch recht fortgeschrittener Stunde nicht mehr
ganz so schoen aussieht, wollte ich diese Korrektur dennoch loswerden.
Nun werden pro Kopiervorgang wenigstens auch 8 bit verschoben und nicht
weniger.
Es gibt da bestimmt noch effizientere Loesungen, aber immerhin sollte
diese jetzt funktionieren.

Hoffe, dass das funktioniert, halbwegs verstaendlich ist und zudem auch noch hilfreich.

[CMatt]

big thx
Werde jetzt mal versuchen den passenden code dazu zu tippen

[CMatt]

Bitte mach dir ne notiz:
"CMatt ist mir ein Bier schuldig wenn wir uns mal über den weg laufen." Das Dinge würde gar mal eben um 30% schneller

[Nobuo T]

Nicht schlecht.

Das Bier werde ich auf dem naechsten Forumtreffen o.ae. dann in Empfang nehmen.