1. C# / Говнокод #17421

    +134

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    using System;
    class ololo
    {
        static void Main()
        {
            int ru, en;
            for (ru = 7700; ru < 8025; ru += 25)
                for (en = 3220; en < 4050; en += 50)
                    Console.WriteLine("Ру " + ru + " и En " + en);
        }
    }

    Нужно было посчитать одновременно от 7700 до 8025 и от 3220 до 4050, в итоге получилось так.

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

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

    • > Нужно было посчитать одновременно от 7700 до 8025 и от 3220 до 4050

      што?
      Ответить
      • Сюжетный поворот: говно в магических константах
        Ответить
    • Это бизнес требование
      Ответить
    • Посчитать(8025,7700, -25) И Посчитать(4050, 3220, -50)
      Ответить
      • Это не одновременно... Тут явно нужен AsParallel.
        Ответить
        • Тут вообще нужен ParallelAss
          Ответить
        • Причём нужно чтобы было два ядра, иначе одновременно может не получицо
          Ответить
        • Ага, еще можно сразу написать клиент-серверное приложение, сервер, который запускает два отдельных экзешника, один считает от 7700 до 8025, воторой от 3220 до 4050 и шлют серверу результаты, которые он обрабатывает.
          Ответить
          • А мне кажется нужно сделать кластер с управляющим сервером, на который передается две задачи, а уже сервер параллелит их рассылая на разные ноды, и ты потом приходишь за результатом.

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

            А еще можно считать на GPU, но только если задачи одинаковые (единое действие для набора данных)
            Ответить
            • > на GPU
              Маловато будет. У той же куды блоки минимум 16 тредов.
              Ответить
              • Ну а откуда Вы знаете что требования не изменятся?

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

                  P.S. Моя не сможет, у нее, к сожалению, всего 960 ядер.
                  Ответить
                  • смотрите ка. отмазался чтоб не делать
                    Ответить
                    • Да на куде это слишком просто... Kernel будет в пару строк, да немножко кода для его запуска. Скучно. Лучше няшек перед сном посмотрю.
                      Ответить
                      • напиши на accelerate
                        http://hackage.haskell.org/package/accelerate
                        Ответить
                        • sum [7700..8025] + sum [3220..4050]?

                          Хотя там, вроде как, именно array надо...
                          Ответить
                        • Ой, а оно не может сгенерить массив, или я невнимательно читаю доку? Обязательно лифтить из обычного?

                          Просто в той же куде можно было по индексам блока и треда нагенерить этих чисел параллельно.
                          Ответить
                          • может генерить, см. функции fill, generate
                            http://community.haskell.org/~simonmar/slides/cadarache2012/7%20-%20accelerate.pdf
                            Ответить
                            • Как-то так:
                              import Data.Array.Accelerate as Acc
                              import Data.Array.Accelerate.CUDA as CUDA
                              
                              type Matrix e = Array DIM2 e
                              
                              rangeGen :: Exp Int -> Exp Int -> Acc (Vector Int)
                              rangeGen low high = generate (index1 (high-low+1)) f where
                                  f ix = let (Z :. i) = unlift ix in Acc.fromIntegral i + low
                              
                              cross :: Acc (Vector Int) -> Acc (Vector Int) -> Acc (Matrix Int)
                              cross v1 v2 = generate (index2 (size v1) (size v2)) f where
                                  f ix = let (Z :. i :. j) = unlift ix in (v1 ! index1 i) * (v2 ! index1 j)
                              
                              main = do
                                  let r1 = rangeGen 7700 8025
                                  let r2 = rangeGen 3220 4050
                                  let c = r1 `cross` r2
                              
                                  print $ CUDA.run $ Acc.sum c
                              Ответить
                              • У тебя не запустилось? А вдруг на идеоне кудкуда есть? Может автор сервиса скрытый латентный фанат
                                Ответить
                                • > У тебя не запустилось?
                                  Почему не запустилось? УМВР. Я даже результат с сишной прогой сверил.

                                  > вдруг на идеоне кудкуда есть
                                  Маловероятно.
                                  Ответить
                                • Там в комплекте интерпретатор есть, которые не требует наличия cuda. А вот сама либа врядли на идеон установлена.
                                  Ответить
                              • Кстати, похоже, бустовая либа скоро появится с похожим функционалом на OpenCL
                                https://kylelutz.github.io/compute/
                                Ответить
                                • Этот boost::compute больше на https://developer.nvidia.com/Thrust похож, чем на accelerate, имхо.
                                  Ответить
                                  • А в чем разница? Сам не смотрел
                                    Ответить
                                    • > А в чем разница?
                                      Ну accelerate более-менее декларативный, а thrust и boost::compute - просто альтернативная версия алгоритмов stl, которая может юзать видюху.
                                      Ответить
                                • Было бы здорово, если бы ввели некий EDSL язык, который транслировался бы с плюсов в опенСиЭл.
                                  Ответить
                                  • На expression pattern? В теории для подобных вещей есть boost.proto, осталось подождать какого-нибудь упоротого маньяка, который это сделает.
                                    Ответить
                                    • Да, именно это и говорю. Но как-то уж и не знаю будут ли ещё плюсы, кроме не читаемых ошибок, которые смогу читать только я и ещё пару кадров. А значит я не заменим и за большие деньги
                                      Ответить
                                  • Ух. Похоже они это и сделали, только как-то очень мрачно:
                                    boost::compute::function<int (int)> add_four =
                                    boost::compute::make_function_from_source<int (int)>(
                                            "add_four",
                                            "int add_four(int x) { return x + 4; }"
                                        );
                                    
                                    boost::compute::transform(input.begin(), input.end(), output.begin(), add_four, queue);
                                    
                                    boost::compute::transform(vector.begin(), vector.end(), vector.begin(), _1 * 3 - 4, queue);
                                    Ответить
                                    • Там что, встроенный крестопарсер? Или так только кёрнелы для opencl можно компильнуть?
                                      Ответить
                                      • Ого. Интересно какой алгоритм в глубине boost::compute::sort?
                                        Ответить
                                        • Пузырёк, лол.

                                          Скорее всего сортирует небольшими блоками каким-нибудь простым алгоритмом, а потом mergesort.
                                          Ответить
                                        • P.S. AssParallel() теперь и в наших крестах.
                                          Ответить
                                          • Я было хотел сказать, что это не он, но сравнив перевод и "транслитерацию" все стало на свои места.
                                            Это GpuParallel, то есть ЖопаПараллель.
                                            Ответить
                                            • Я вот всех вас сейчас обрадую. Майкрософт проект софтварная транзакционная память STM.NET закрыла. А также закрыли разработку китайцы проуессора с хардварной транзакционной памятью. Так что будем мы и дальше сасать примитивную лапу локов
                                              Ответить
                                              • Кстати, если кому интересно: современные планировщики задач


                                                Новый диспетчер задач в таких сценариях поступает более изощренно – у каждого потока есть своя локальная очередь и каждая дочерняя задача помещается в эту локальную очередь, а не в общую. Таким образом, нагрузка на общую очередь существенно снижается. При этом выборка из локальной очереди производится по принципу LIFO – в этом случае выше вероятность, что данные необходимые для задачи, забираемой из очереди на выполнение, все еще достаточно "горячи", чтобы не вылететь из кэша.

                                                Потенциально здесь кроется проблема, связанная с тем, что локальные очереди с очень большой вероятностью будут разными по размеру, и, пока один поток разгребает свою очередь, другой может простаивать без дела. Чтобы этого избежать, алгоритм поиска новой задачи для потока выглядит так – сначала просматривается локальная очередь потока, если там пусто, то просматривается глобальная очередь. Если пусто и там, просматриваются локальные очереди соседних потоков (механизм, что характерно, называется work stealing). При этом доступ к локальным очередям соседей уже опять происходит по принципу FIFO, чтобы не мешаться со своей помощью...
                                                Ответить
                                                • Уже обсуждалось
                                                  http://govnokod.ru/13909#comment198947
                                                  На IO они не очень. Только на вычислительных задачах с предсказуемым временем окончания и низкой латенси.
                                                  Ответить
                                              • >А также закрыли разработку китайцы проуессора с хардварной транзакционной памятью.
                                                Когда-то постил новость что интел у себя баг нашли и тоже на время залочили TSX.
                                                Видимо не такая это простая в реализации штука.
                                                Ответить

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