1. Си / Говнокод #17408

    +143

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    void ** __attribute__((noinline)) findVoidSortMap(void ** list,void *key)
{
    if (!list) return 0;
    if (!*list) return 0;
    unsigned int count= **(unsigned int**)list;
    char *p=(char*)*list;
    p+=4;
    Element *b=(Element *)p;
 
    long long skey=(long long)key;
 
    while (count>0) {
        void** kt=(void**)&b[count>>1];
        long long rkey=(long long)kt[0];
        if (skey==rkey) return (void**)&kt[1];
        if (skey>rkey) {b+=(count>>1)+1;count--;}
        count=count>>1;
    }
 
    return (void**)-1;
}

    гуру осемблира на этом коде доказывал, что Эльбрус сосёт
    http://www.gamedev.ru/flame/forum/?id=196722&page=33#m481

    Запостил: TarasB, 05 Января 2015

    Комментарии (45) RSS

    • ava TarasB 05.01.2015 17:21 # +3

      Вот нахуй так писать?!
      Ответить

    • ava gost 05.01.2015 17:35 # 0

      >>> по меньше виртуальной теории и по больше практики и программирования на assemblere!
      В 2015 году. Круто.
      А автору сего предложения не помешала бы практика языка "русский".
      Ответить

    • ava Dummy00001 05.01.2015 18:27 # 0

      это вообще что делает?

      16я строка намекает на какую-то структуру данных.
      Ответить

      • ava wvxvw 05.01.2015 18:51 # +2

        > это вообще что делает?
        Указатель на указатель пустоты, минус один, это же очевидно!
        Ответить

    • ava 3.14159265 05.01.2015 19:25 # 0

      Кстати, Тарас, а что там выяснилось по итогам эльбрусотреда, лень 100 страниц срача читать.
      Есть какие голые цифры?
      Ответить

      • ava TarasB 05.01.2015 20:47 # 0

        На одной из предыдущих страниц есть графики. В среднм как интел вдвое большей частоты но очень зауисит от теста гдето лучше гдето хуже а на высерах школоло кулхацкеров типа этого ваще сливается потгму что компилятор небось на такую хуиту не затачивали
        Ответить

        • ava 3.14159265 05.01.2015 21:08 # 0

          >На одной из предыдущих страниц есть графики.
          На 90-100х?

          >В среднм как интел вдвое большей частоты
          А за счёт чего получается такой большой IPC? И там же джва режима - один нативный, другой эмуляция x86.

          >но очень зауисит от теста гдето лучше гдето хуже
          Практически весь софт в той или иной мере годами точился под интел (80% рынка не хухры-мухры). Ассемблерные вставки и прочие специфичные тюны пройдут мимо эльбруса.

          Надо делать на это скидку. Вообще думал будет много хуже. А так 65нм, миллиард транзисторов, неплохое энергопотребление и очень неплохой как для отечественной разработки (пусть и спижженой) пирфоманс.
          Ответить

          • ava TarasB 05.01.2015 21:23 # +1

            Че там всего тридцать с хреяом страниц листай с конца ищи картинки выигрыш за счет параллельности оманд
            Ответить

        • ava Xom94ok 05.01.2015 21:35 # 0

          > компилятор небось на такую хуиту не затачивали
          Его под векторизацию затачивали. Там даже DSP можно программировать на подмножестве крестов :) Где-то на сайте МЦСТ есть методички "как помочь компилятору векторизировать код", которая и близко не похоже на код в посте.
          Ответить

          • ava guest 10.01.2015 16:09 # 0

            А есть ли методичка "как нахваливать зделаныйунас величественный эльбурс, не предоставляя никаких количественных оценок"?

            > В среднм как интел вдвое большей частоты
            Вот это я читал больше года назад и с тех пор ничего конкретнее.
            Ответить

    • ava laMer007 05.01.2015 22:12 # 0

      > Эльбрус сосёт
      > 70 тыс.р.
      Ясно
      Ответить

      • ava 3.14159265 05.01.2015 22:17 # 0

        > 70 тыс.р.
        Откуда цифра?
        Ответить

        • ava laMer007 05.01.2015 22:36 # 0

          Барыга из инета моноблок с эльбрусом хотел продать. 10тр может и наварил
          Ответить

          • ava 3.14159265 05.01.2015 22:38 # 0

            Дык этаж целый моноблок! Недорого я скажу, как за потенциально раритетную вещь.
            Ответить

            • ava laMer007 05.01.2015 22:39 # +3

              Я уж лучше моноблок от эпла куплю и анальную смазку на остаток средств
              Ответить

              • ava 3.14159265 05.01.2015 22:40 # 0

                А какой это моноблок эппла стоит 70К р.?
                >и анальную смазку на остаток средств
                Мсьё знает толк...
                Ответить

                • ava guest 10.01.2015 21:38 # 0

                  Сейчас ноутбук от эпла из-за мегабакса не купишь за 70
                  Ответить

      • ava DlangGovno 06.01.2015 01:52 # +4

        > 70 тыс.р.
        Тарасу предложи, пока у него бабло не кончилось. Пусть свои поделия попортирует.
        Ответить

    • ava bormand 06.01.2015 10:07 # 0

      А там полный код есть? По этой функции не совсем понятно, что такое Element.
      Ответить

      • ava bormand 10.01.2015 12:47 # 0

        Всё, разобрался в этой параше. Девиз автора - структуры для нубов, настоящие пацаны копаются в памяти руками. А на самом деле это всего лишь двоичный поиск в чём-то типа:
        typedef struct Element_ {
    void * key;
    void * value;
} Element;

typedef struct List {
    unsigned int count;
    Element * data;
};
        Причём key сравнивается не по контенту, а на равенство указателей.
        Ответить

        • ava bormand 10.01.2015 12:54 # 0

          Вот так вроде бы правильней будет:
          typedef struct List {
    unsigned int count;
    Element data[0];
};

// вызов
List *list = malloc(sizeof(List) + sizeof(Element) * count);
list->count = count;
findVoidSortMap(&list, key);
          Ответить

        • ava roman-kashitsyn 10.01.2015 15:59 # 0

          > на самом деле это всего лишь двоичный поиск
          Оффтоп: удивительно, насколько паршиво в STL сделан поиск по ключу в сортированных векторах.
          Ответить

          • ava bormand 10.01.2015 16:01 # 0

            Насколько?

            P.S. lower_bound() и upper_bound()?
            Ответить

            • ava roman-kashitsyn 10.01.2015 16:03 # 0

              > Насколько?
              по моей шкале отвратительности - NaN
              Ответить

            • ava roman-kashitsyn 10.01.2015 16:04 # 0

              > lower_bound() и upper_bound()?
              А теперь предположим, что вектор структур отсортирован по полю (имя/ид/дата/етц), у меня есть значение поля, и я хочу найти соответствующую структуру...
              Ответить

              • ava Soul_re@ver 10.01.2015 16:19 # 0

                >А теперь предположим, что вектор структур отсортирован по полю (имя/ид/дата/етц), у меня есть значение поля, и я хочу найти соответствующую структуру...

                equal_range с кастомным компаратором?
                Ответить

              • ava bormand 10.01.2015 22:30 # 0

                Если ключи уникальны - lower_bound() с компаратором по полю + допроверка ключа. Некрасиво, да.

                Если ключи не уникальны - equals_range() с тем же компаратором (или lower_bound() + upper_bound()). А тут чего плохого?
                Ответить

                • ava roman-kashitsyn 11.01.2015 00:51 # +1

                  Нет, компаратор для сортировки должен принимать две структуры, компаратор lower_bound - структуру и ключ, компаратор upper_bound - ключ и структуру.
                  Т.е. либо писать разные компараторы, либо писать в одном три унылых bool operator() в одном компараторе.
                  А недавно нужно было отсортировать массив индексов другого массива, содержащего числа...
                  В общем, линз вроде пистоньего key=f определённо не хватает.
                  Ответить

                  • ava Xom94ok 11.01.2015 01:46 # +2

                    > линз вроде пистоньего key=f определённо не хватает
                    Всем стоять-бояться, LINQ for C++ спешит на помощь!
                    https://cpplinq.codeplex.com/
                    Ответить

                  • ava bormand 11.01.2015 01:46 # 0

                    Да, теперь я понял в чем проблема. Я просто никогда компаратор не отдавал в lower_bound, поэтому сразу не дошло.
                    Ответить

                  • ava LispGovno 11.01.2015 12:15 # 0

                    Да ты поехавший. Структуру в T передавай. Одно поле ключа заполни, остальные в дефолт
                    Ответить

                  • ava LispGovno 11.01.2015 12:28 # 0

                    >В общем, линз вроде пистоньего key=f определённо не хватает.

                    Что линзы то делают?

                    Стоп, ты предлагаешь в язык ввести синтаксический сахарок только из-за одной неправильнонаписанной функции? круто бро. функцию исправленную просто надо добавить
                    Ответить

                    • ava roman-kashitsyn 11.01.2015 12:39 # 0

                      > Стоп, ты предлагаешь в язык ввести синтаксический сахарок только из-за одной неправильнонаписанной функции? круто бро.

                      Ты с дуба упал?

                      Я говорю не о синтаксическом сахаре, а об организации API.
                      В пистоне функция сортировки опционально берёт на вход функцию, отображающую множество элементов массива на произвольное упорядоченное множество. Linq-овский OrderBy работает так же. Такое апи позволило бы иметь один компаратор на sort, upper_bound, lower_bound, equal_range.
                      Ответить

                      • ava bormand 11.01.2015 13:08 # 0

                        > один компаратор на sort, upper_bound, lower_bound, equal_range.
                        Как-то так, наверное:
                        template <typename S, typename K, typename GetKey, typename Less>
class key_comparator {
public:
    key_comparator(GetKey get_key, Less less) : get_key(get_key), compare(compare) {}
    bool operator()(const S &a, const S &b) { return less(get_key(a), get_key(b)); }
    bool operator()(const S &a, const K &b) { return less(get_key(a), b); }
    bool operator()(const K &a, const S &b) { return less(a, get_key(b)); }
private:
    GetKey get_key;
    Less less;
};

template <typename S, typename K, typename GetKey>
key_comparator<S, K, GetKey, std::less<K> > make_key_comparator(GetKey get_key) {
    return key_comparator<S, K, GetKey, std::less<K> >(get_key, std::less<K>());
}

template <typename S, typename K, typename GetKey, typename Less>
key_comparator<S, K, GetKey, Less> make_key_comparator(GetKey get_key, Less less) {
    return key_comparator<S, K, GetKey, Less>(get_key, less);
}
                        Ответить

                        • ava bormand 11.01.2015 13:10 # 0

                          P.S. Плохо, что типы S и K нельзя извлечь из GetKey, а придётся передавать руками в make_key_comparator<>().
                          Ответить

                          • ava LispGovno 11.01.2015 14:35 # 0

                            std::result_of
                            Ответить

                            • ava bormand 11.01.2015 14:54 # 0

                              Ну это результат. А вот с аргументом, походу, придётся соснуть хуйцов.

                              P.S. Хотя вроде бы нашлась какая-то реализация function_traits.
                              Ответить

                              • ava LispGovno 11.01.2015 15:14 # 0

                                осталось добавить в борманд либ на гитхабе))))
                                Ответить

                                • ava bormand 11.01.2015 15:47 # 0

                                  Блин, зря я себе такой ник выбрал. Борланд обидится, если я начну пилить bormand's c++ library.

                                  P.S. Хотя... борланд же мёртв.
                                  Ответить

                        • ava roman-kashitsyn 11.01.2015 18:42 # +1

                          Есть ещё неприятный, но вполне возможный кейс, когда типы K и S совпадают. Так что всех проблем это не решает.
                          Ответить

                          • ava bormand 11.01.2015 18:57 # 0

                            > когда типы K и S совпадают
                            Да, это фейл. Тут только цель руками указывать остается... comparator.for_lower_bound(), comparator.for_sort() и т.п. Жопа.
                            Ответить

                          • ava bormand 11.01.2015 19:06 # 0

                            P.S. Походу, проще запилить новые функции с кошерным интерфейсом, чем возиться с теми. Там алгоритм то простейший (ну кроме сорта разве что).
                            Ответить

    Добавить комментарий