Eine der ersten Evolutionsstufen war eine ziemlich elegant aussehende Ersetzung der inneren Schleife. Die Performance ist da zwar sicher noch nicht am Limit, jedoch ist der Code sehr übersichtlich und schon schneller als der vorhergehende ohne Inline-Assembler.

unsigned long mem0s(unsigned char *s, unsigned long l) {
        unsigned long r=0, i=0, j;
        unsigned char mem_read;

        while(i
                mem_read=~(s[i]);

                asm volatile (

                        "ctpop %1, %0 \n\t":

                        "=r"(mem_read): "r"(mem_read)
                );

                r+=mem_read;

                i += 1;
        }

        return r;
}

Ich persönlich finde sogar diese Version deutlich übersichtlicher als die vorige, von der Angabe gar nicht zu reden. Übersichtlichkeit ist bekannterweise fast das gleiche wie Wartbarkeit.

Auch für den Lesendzugriff gibt es zahlreiche Methoden, die wieder auf einzelne Fälle spezialisiert sind. Hilfreich ist, wie fast immer beim Programmieren, zuerst die Dokumentation auf nützliche Methoden zu untersuchen und erst dann gegebenenfalls Dinge selber auszuprogrammieren. Stichwort: Durchsuchen einer ArrayList, Sortieren, Elementweise Bearbeitungen, und so weiter. Beschreibe ich alles noch, keine Sorge!

• ArrayList.get(Index) ist hilfreich, wenn man den Index eines Wertes bereits kennt und diesen Auslesen will. Als Suchergebnis -- mehr zur Suche im folgenden Abschnitt -- bekommt man meistens genau so einen Index.
• ArrayList.toArray() liefert die ArrayList als normales JAVA-Array zurück. Die Reihenfolge der Elemente entspricht dabei der der ArrayList. Nützlich für manche Methoden, die explizit ein "gewöhnliches" Array verlangen.
• ArrayList.toArray(Objekt[] a) liefert alle Elemente des angegebenen Objekttyps aus der ArrayList zurück. Zur Erinnerung: Es können beliebige Elemente unterschiedlichster Typen in die ArrayList geschrieben werden. Manchmal ist es dennoch wünschenswert, beispielsweise nur alle Strings gesammelt zu haben. Das ginge dann mit ArrayList.toArray(String[] a).
• ArrayList.toString() geht zwar mit fast allen Objekten, ich möchte es aber hier nochmal besonders herausstreichen. toString wandelt die ArrayList in einen lesbaren String um, den man sich zB zwecks Debugging ausgeben kann.

Neben diesen allgemeinen Tips kann man auch noch einzelne Operationen optimieren. Head oder Tail beispielsweise hat Risewind aus dem Informatik-Forum so gelöst:

246 print_head(int rs1, int rd) {
247 
248         trace("# print_head(%d, %d)\n",
249                 rs1, rd);
250 
251         check_list(rs1);
252 
253 
254         /* wieder ein genialer Peter-Trick...
255         */
256 
257         printf("\tldq $%d, -1($%d)\n",
258                 rd, rs1);
259 
260         force_valid_list(rd);
261 }
262 
263 
264 
301 print_tail(int rs1, int rd) {
302 
303         trace("# print_tail(%d, %d)\n",
304                 rs1, rd);
305 
306         check_list(rs1);
307 
308         printf("\tldq $%d, 7($%d)\n",
309                 rd, rs1);
310 
311         force_valid_list(rd);
312 }

Der erzeugte Code:

==========> Eingabe von /usr/ftp/pub/ublu/test/code/b5.in:
hd $17

Übersetzung: Status korrekt

Ausgabe:
blbc $17, raisesig
ldq $0, -1($17)

Übersetze und linke das Testprogramm:

Rufe folgendes Codefragment auf:
return testasm(a,b,c,d) != head(b);

Erzeugter Code verhaelt sich bezueglich Signal-Erzeugung wie erwartet
und das Ergebnis des Ausdrucks ist korrekt.

==========> Eingabe von /usr/ftp/pub/ublu/test/code/b6.in:
tl $19

Übersetzung: Status korrekt

Ausgabe:
blbc $19, raisesig
ldq $0, 7($19)

Übersetze und linke das Testprogramm:

Rufe folgendes Codefragment auf:
return testasm(a,b,c,d) != tail(d);

Erzeugter Code verhaelt sich bezueglich Signal-Erzeugung wie erwartet
und das Ergebnis des Ausdrucks ist korrekt.