Вот назрел вопрос о создании процедуры сравнения двух блоков памяти и нахождение кол-ва не совпадений.
Задача такая, блоки памяти одинакового размера и всегда кратны 4. Сравнение идет не по байтам , а по DWORD.
Стандартная CompareMem в Delphi пашет очень быстро, сравнение двух блоков по 30 мегов каждый проходит за 40-42 тика (GetTickCount до и после), но эта процедура выходит при нахождении первого не совпадения.
Я набросал простой вариант

по скорости также как и CompareMem , но вот думаю может можно как то еще ускорить? У кого есть идеи?

Ray Adams, зачем тебе такая суперскорость?
и ... может все-же сделать asm вставку?

Будет быстрее на пару тиков процессора

Asteroid Как раз нет, я специально смотрел что получается в АСМе, так вот

ты уверен что это меньше в асме? Я нет

serj_
Да вот понадобилось , насчет асма, так этот код Delphi сам прекрасно перевел в асм , даже лучше чем я сам бы это сделал.
Просто подумываю над чем то иным, скажем с применение SSE !

ага! давай, давай ... и получишь дикий провал для AMD.
Ладно, не хочешь сознаваться - твои проблемы.
Если сравниваются большие блоки, очень помогает prefetchnta. Для сравнения надо их выдавать два раза.
Кроме того, обязательно надо align 16 по первой инструкции цикла. И ... цикл с одной проверкой внутри себя - это уже порядка х2 меньше скорость.
Операции надо-бы делать с блоком.
(ты все еще хочешь обойтись без asm? )

Ray Adams
по алгоритму: сравнение есть вычитание и если нужно знать количество всех несовпадений вычитать нужно все
оптимизировать тут практически нечего
по реализации: лучше всего конечно асмовская вставка - никакой компилятор не сможет понять что все что тебе нужно есть подобие repe cmps но рассматривая код сгенерированный делфи много чего есть улучшить не прибегая к асму и оптимизации под конкретные процессоры, выравнивания, парабельность команд, sse и т.п.
1. избегаем локальных переменных - они храняться в стеке - что есть память и работа с ними медленнее чем с регистрами; полезно также знать что делфи при использовании стандартного вызова fastcall старается разместить параметры в регистрах:
учитывая все это и то что с p1 и p2 работаем в цикле присваивание dw1:=p1; dw2:=p2; явно невыгодно (переносим переменные в медленную память из быстрого процессора )
2. мелкая оптимизация по размеру + помещение переменной в регистр
вместо ms:=size div 4 лучше написать size:=size shr 2;
3. использование цикла while do вместо for to - избавляемся от лишней локальной (стековой) переменной i

в результате получается что-то типа этого - возможно даже заработает - я не проверял

serj_ Да я согласен и на АСМ, галвное чтобы быстро было, а что SSE такой фиговый под AMD полчуается? Ну тогда можно и на MMX, хотя это всеже тривиальная задача и все решается простейшими способами.

Сознаваться в чем?

stargaz0r проверил таже скорость 62 тика. Видимо уже оптимизировать это только перевода на АСМ хотя не уверен в том что будет лучше.
Но надо попробовать.

Ray Adams
проверять стоит для самого плохого случая - сравни один и тотже блок памяти с самим собой со сдвигом на дворд

stargaz0r не совсем понял как именно это сделать
может модифицировать стандартную процедуру?

Ray Adams
ну к примеру если p1=$a000 то p2=$a004
можно и модифицировать - заметь - repe cmpsd - как я и предлагал

Да кстати вот это не верно
inc(integer(p1), 4);
inc(integer(p2), 4);
надо
inc(dword(p1));
inc(dword(p2));

Ray Adams
ну если ты собрался сравнивать дворды побайтно, то конечно

Чисто навскидку


лучше заменить на add и sub, они на P4 быстрее исполняются AFAIK



то же самое, на современных процессорах аналог из простых команд будет быстрее

все адреса переходов выравнять по 16-байтной границе

GReY

делфи это как раз в add и sub компилирует


на basm это трудновыполнимо