Pull to refresh
16
0

Пользователь

Send message

А я уже тестил с оптимизацией s1[i] за границей цикла. Иначе (на вашем оригинальном коде) в шланге9 дикая регрессия больше чем в два раза!

У меня разница между шланг8 и шланг9 минимальна. 8-ой шланг действительно дает маленькую регрессию при с++17.

наверное про векторизацию я нагнал и это был код iota

интересно что у меня на clang++8 если ставить флаг -std=gun++2a вместо -std=gnu++17 есть прирост где-то на 8%.
К тому же еще странно как у вас шланг так сливает гцц, я вот захожу на годболт, и там шланг векторизирует а гцц нет, и у меня на машине шланг8 быстрее гцц9.1. Сейчас поставлю новые версии.
Еще расту тоже надо указывать -C "target-cpu=native для честности. Кстати хаскелю наверное тоже что то такое т.к. это флаг скорее всего для ллвм.

ну запусти сам и проверь разницу 15 и 20 тыс.

Если по кэшу нет разницы то логично.

так numba это не ffi

а зачем на с++ используется int64?

на любом языке можно писать на фортране

С вашего позволения продолжу вопрос про перегрузки. Для конкретного типа (например Foo<int>, Foo<float>) понятно как делать специализацию потому что есть однозначность. Но в том что я имел ввиду про Foo<f(10)> и Foo<g(3)> — тут например конкретный тип не известен пока не вычислим f(10) и g(3). Или например перегрузка по неким трейтам ака enable_if. Я вижу проблему в том что как узнать какая имплементация более узкая а какая более широкая, как узнать могут ли эти множетсва одного instance и другого instance перекрываться. Как это проблема решается?


Upd. поправил код который съел хабр

Речь не про длину данных, а про размер одного элемнта. Или например можно навесить аттрибут на тип про то насколько дорогая функция сравнения двух элементов. Но не так существенно для моего вопроса — я это детально не изучал.

Но конкретно в хаскеле у вас (пока что) будет отдельная функция для рантайм-вычислений, и отдельная — для компилтайм (вернее, для вычислений во время тайпчекинга)

ну хотелось бы писать компайл тайм функции так же удобно как рантайм т.е. чтобы арифметические операции как обычно хотя бы были. Один из примеров это какой-то ручной unroll зависящий от каких-то констант и функций от них. Или пример навеянный докладом Александреску, у нас есть какие то структуры мы знаем их размер или другие характеристики далее хотим в зависимости от этого подогнать параметры quick sort т.е. сделать перегрузку функции сортировки.


Вообщем-то интересно разобратся как это все формализовать иначе какие-то одни обрывки.


Ну и собственно есть ли альтернатива тому как это сделано в С++ когда все разбирается по ходу дела?


Например с одной стороны мне нужно знать одно и то же Foo<f(10)> и Foo<g(3)> — я могу пойти вычислять это всё, но с другой стороны чтобы вычислить мне надо про тайпчекнуть f и g, а если внутри f или g есть какой-то Foo<?>, как избегать таких ситуаций?


Ну а с другой стороны если допустим я перенесу это на другой уровень и скажу ладно компайл тайм функции пишем через какие то стремные типы как сделано в typenum в расте через например тупли вида (1, (0, (1, 0))) = 10. Что это будет значить для этой надстройки над языком, будут ли там такие же такие гарантии как и в самом языке или мы в некотором смысле обходим тайпчекинг?

Ну так посмотри на доку любой JS/python либы там идет описание на пару строчек а дальше перечисление какого типа какой аргумент. А зачем так делать если это можно написать в сигнатуре и автоматом получить проверку аргументов на соответствие нужным типам и дополнительные подсказки компилятору для оптимизаций.

Очень конструктивно

Ну да потому что если в том буфере char* на самом деле лежит T то можно делать reinterpert_cast к T* и дальше работать с ним. т.е. ваш первый пункт из сообщения про UB, в документации без поллитра не разберешься.

Нет отрицание этого выражение это то что char* можно читать как что то другое (но не что угодно)

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


Upd; даже не так, а еще для остальных n определить рекурсивно через 3 и 10 (например).

А при чем тут это? Если я имел ввиду константные темплейт аргументы fn f<{3}>() { ... }

Т.е. перегрузка не только по типу но и по какому-то значению типа factorial(3) сработает?

А вот это странно, что aliasing не симметричный. Т.е. что угодно можно читать как char* но char* нельзя читать как что то другое. Скорее всего так сделано потому что не только алиасинг но еще и выравнивание. Хотя выравнивание зависит от платформы так что это неким общим документом боюсь не опишешь. Иначе у меня вопрос как писать SSE инструкции? Это скорее всего исключения типа char*.

Information

Rating
5,071-st
Registered
Activity