Самый быстрый способ узнать минимум 3 чисел?

Да, пост Сборка, но моя наивная оптимизация:

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{
    unsigned int m = a;
    if (m > b) m = b;
    if (m > c) return c;
    return m;
}

Во-первых, посмотрите на разборку. Это много скажет вам. Например, как написано, есть 2 if-quilentments (что означает, что существует 2 возможных ошибки отделения), но я предполагаю, что приличный современный компилятор C будет иметь некоторую умную оптимизацию, которая может сделать это без ветви. Мне было бы любопытно узнать.

Во-вторых, если ваша libc имеет специальные встроенные функции min / max, используйте их. GNU LIBC имеет FMIN / FMAX для плавающей точки, например, и они утверждают, что «на некоторых процессорах этих функций могут использовать специальные инструкции по машине для выполнения этих операций быстрее, чем эквивалентный C-код». Может быть, есть что-то подобное для Uints.

Наконец, если вы делаете это с кучей чисел параллельно, возможно, существует векторные инструкции для этого, что может обеспечить значительное ускорение. Но я даже видел, что неконкуратный код будет быстрее при использовании векторных единиц. Что-то вроде «Загрузите один UINT в векторный реестр, вызов векторной мин функции, получить результат», выглядит тупой, но на самом деле может быть быстрее.

Вы можете попробовать что-то вроде этого, чтобы сэкономить на декларации и ненужных сравнениях:

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{ 
    if (a < b)
    {
        if (a < c) 
             return a; 
        else 
             return c;
    }

    if (b < c)
        return b;
    else return c;
}

Мои взять на реализацию ассемблера X86, синтаксис GCC. Должен быть тривиальным для перевода на другой встроенный монтажный синтаксис:

int inline least (int a, int b, int c)
{
  int result;
  __asm__ ("mov     %1, %0\n\t"
           "cmp     %0, %2\n\t" 
           "cmovle  %2, %0\n\t"
           "cmp     %0, %3\n\t"
           "cmovle  %3, %0\n\t" 
          : "=r"(result) : 
            "r"(a), "r"(b), "r"(c)
          );
  return result;
}

Новая и улучшенная версия:

int inline least (int a, int b, int c)
{
  __asm__ (
           "cmp     %0, %1\n\t" 
           "cmovle  %1, %0\n\t"
           "cmp     %0, %2\n\t"
           "cmovle  %2, %0\n\t" 
          : "+r"(a) : 
            "%r"(b), "r"(c)
          );
  return a;
}

Примечание: это может или не может быть быстрее, чем C-кода.

Это зависит от многих факторов. Обычно CMOv выигрывает, если ветви не предсказуются (на некоторых архитектурах X86) OTOH INLine Assembler всегда является проблемой для оптимизатора, поэтому наказание на оптимизацию для окружающего кода может быть возведена на все преимущества ..

BTW Sudhanshu, было бы интересно Чтобы услышать, как этот код выполняет с помощью TestData.

Это все хорошие ответы. Рискуя быть обвиненным в том, что я не ответил на вопрос, я бы посмотрел и на другие 80%. Стекшоты - мой любимый способ найти код, который стоит оптимизировать, особенно если это вызовы функций, которые, как Вы выяснили, Вам не совсем нужны.

Как насчет использования начального состояния...

int enter_dblquotes = 0;

%x DBLQUOTES
%%

\"  { BEGIN(DBLQUOTES); enter_dblquotes++; }

<DBLQUOTES>*\" 
{ 
   if (enter_dblquotes){
       handle_this_dblquotes(yytext); 
       BEGIN(INITIAL); /* revert back to normal */
       enter_dblquotes--; 
   } 
}
         ...more rules follow...

Он был аналогичен этому эффекту (flex использует % s или % x для указания ожидаемого состояния. Когда вход Flex обнаруживает кавычку, он переключается в другое состояние, а затем продолжает лексировать до тех пор, пока не достигнет другой кавычки, в которой он возвращается в нормальное состояние.

Sinkhole предприятия:

1: прочитайте, что доступ к базе данных должен быть на отдельном уровне

2: Эй, у нас есть уровень базы данных.

2 (b) Эй, у нас даже есть делегированный слой, чтобы абстрагироваться от нашей базы данных.

3: Примените закон утечек абстракций -i.e, так как в делегатах есть методы, которые получают вещи, просто предположим, что они там, чтобы использовать без мысли о последствиях - как в вызове «getPurchaseOrder ()» 10 раз подряд на странице, даже если getPurchaseOrder () является методом, который оборачивается 5 отдельных вызовов базы данных.

4: Сидите и наслаждайтесь своими веб-страницами, которые загружаются с 100 отдельными вызовами базы данных (к сожалению, не преувеличение).

Не уверен, что я бы назвал это антиобразцом? Может быть «Слои не свободны»?

На моем AMD Phenom этот запасной час примерно на 1,5% быстрее:

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{
    asm("cmp   %1,%0\n"
        "cmova %1,%0\n"
        "cmp   %2,%0\n"
        "cmova %2,%0\n"
        : "+r" (a) : "r" (b), "r" (c));
    return a;
}

Результаты могут варьироваться; Некоторые процессоры x86 не очень хорошо работают с CMOV.

Расширения инструкций SSE2 содержат целое число min обучение, которое может выбрать 8 минимумов одновременно. Смотри _mm_mulhi_epu16 в в http://www.intel.com/software/products/compilers/clin/docs/ug_cpp /comm1046.htm

Если Вы проводите только одно сравнение, то, возможно, Вам захочется разворачивать цикл вручную.

Сначала посмотрите, можно ли заставить компилятор разворачивать цикл за вас, а если нет, то сделайте это сами. Это, по крайней мере, уменьшит накладные расходы на управление циклом...

Если предположить, что ваш компилятор не готов к обеду, то он должен скомпилироваться до двух сравнений и двух условных ходов. Лучше не бывает.

Если вы опубликуете сборку, которую на самом деле генерирует ваш компилятор, мы увидим, нет ли чего-нибудь ненужного, что замедляет его работу.

Первое, что нужно проверить, это то, что рутина на самом деле становится inlined. Компилятор не обязан это делать, и если он генерирует вызов функции, то это будет очень дорого стоить для такой простой операции.

Если вызов действительно получает inlined, то разворачивание цикла может быть полезным, как говорил DigitalRoss, или векторизация может быть возможна.

Правка: Если вы хотите векторизовать код, и используете недавний процессор x86, то вы захотите использовать инструкцию SSE4.1 pminud (intrinsic: _mm_min_epu32), которая берет два вектора по четыре беззнаковых инта в каждом и производит вектор из четырех беззнаковых инта. Каждый элемент результата является минимумом соответствующих элементов в двух входах.

Я также отмечаю, что ваш компилятор использовал ветки вместо условных ходов; вероятно, вам следует сначала попробовать версию, которая использует условные ходы, и посмотреть, получится ли от этого хоть какое-то ускорение, прежде чем вы выйдете на гонки по векторной реализации.