LINUX.ORG.RU

Вышел GNU Guile 2.0.7

 , , ,


1

3

Вышла новая версия реализации языка Scheme — GNU Guile 2.0.7. Несмотря на незначительное изменение номера версии, появились несколько интересных нововведений, а именно:

  • Полная поддержка инфиксных выражений (curly-infix-expressions). Теперь вместо (* a (+ b c)) можно писать {a * {b + c}}.
  • Поддержка разных опции чтения (read option) для разных портов.
  • Поддержка вложенных директив future.
  • Специальный синтаксис для добавления путей в переменные окружения GUILE_LOAD_PATH и GUILE_LOAD_COMPILED_PATH в конец списка путей, а не в начало.
  • Исправлен недочет в функции load-in-vicinity, которая не сканировала директории, установленные в переменной %load-compiled-path.
  • Исправлен порядок поиска расширений. Теперь Guile не изменяет для этого переменную окружения LD_LIBRARY_PATH.
  • Функция make-vtable-vtable помечена устаревшей, рекомендуется использовать make-vtable и <standard-vtable>.
  • Оптимизированы вызовы equal? и eqv? для случаев, когда один из аргументов — константа.
  • Новые предупреждения компилятора -Wduplicate-case-datum и -Wbad-case-datum.
  • Многочисленные незначительные улучшения и исправления ошибок.

>>> Подробности

★★★★★

Проверено: tazhate ()

Ответ на: комментарий от ugoday

Согласен, в этом смысле у них полный паритет с guile.

(ухмылка) Пункт номер 2: батарейки.

anonymous ()
Ответ на: комментарий от Deleted

Хочу тоже иметь оклады как у этих самых «ассенизаторов» (от 150тр на руки)

В год рублей?

anonymous ()
Ответ на: комментарий от anonymous

Конкретная специализация generic называется method.

Я в курсе

Делаешь (apropos «method» nil t), и видишь, что тебе нужно

То бишь все вручную? А хотелось по запросу получать список методов и выбирать прямо там, какой хочешь бахнуть.

Sectoid ★★★★★ ()
Ответ на: комментарий от Zubok

slime-inspector

Ага. Им воспользоваться для дженериков я как-то не подумал. Спасибо, теперь заживем! =)

Sectoid ★★★★★ ()
Ответ на: комментарий от psikh

Ты болен, и тебе нужно лечиться. Срочно.

1. я не говорил что что-то уделало что-то другое.

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

Возражения по-существу будут, или будешь и дальше метан пускать?

rtvd ★★★★★ ()
Ответ на: комментарий от anonymous

Кстати, о батарейках. Когда все питонолибы перейдут на питон 3?

ugoday ★★★★★ ()
Ответ на: комментарий от ugoday

Кстати, о батарейках. Когда все питонолибы перейдут на питон 3?

Эх, гайлу бы проблемы пайтона. :)

anonymous ()
Ответ на: комментарий от anonymous

Мне, просто интересно, а ты как питоноадвокат наверное в теме. В каком состоянии переход 2->3?

ugoday ★★★★★ ()
Ответ на: комментарий от ugoday

Зайди в девелопмент,там как раз тема про это сейчас.

provaton ★★★★★ ()
Ответ на: комментарий от ugoday

Вопрос такой, как будто пайтон чем-то отличается от других проектов со схожим уровнем популярности при смене мажорной версии. Ответ на него зависит от дистрибутива и легко получается изучением репозитория.

anonymous ()
Ответ на: комментарий от rtvd

Ну конечно же, бенчмарки, по которым говнолисп в глубокой оппе - конечно же «убоги». Это все загойвор вольных каменщиков!

psikh ()
Ответ на: комментарий от rtvd

Смотри сюда:

http://shootout.alioth.debian.org/u64/benchmark.php?test=knucleotide&lang...

Видишь задание?

Теперь глянь на решения:

http://shootout.alioth.debian.org/u64/program.php?test=knucleotide&lang=r...

и

http://shootout.alioth.debian.org/u64/program.php?test=knucleotide&lang=j...

Ничего забавного не видишь?

Подсказываю:

* В условии сказано «extract DNA sequence THREE». Код на Java найдёт DNA последовательность, что начинается на «THR».

if (line[0] == '>' && line[1] == 'T' && line[2] == 'H' && line[3] == 'R') {

Т.е. код глючен, но его приняли. И эта программа стоит в верху списка.

* В условии сказано «count all the 3- 4- 6- 12- and 18-nucleotide sequences, and write the count and code for the specific sequences GGT GGTA GGTATT GGTATTTTAATT GGTATTTTAATTTATAGT». Глянь на код на Racket.

(for ([seq '(«GGT» «GGTA» «GGTATT» «GGTATTTTAATT» «GGTATTTTAATTTATAGT»)]) 
  (write-one-freq (all-counts (string-length seq) dna)
                  (string->symbol seq)))

Видишь, они не вычисляют частоты а потом ищут среди результатов то, что нужно. Они вычисляют частоты для каждой из последовательностей отдельно. А это совсем другой Алгоритм. И ничего, код принят. К тому же этот код, найдя «> THREE» будет дальше читать последовательность не останавливаясь. Т.е. если потом будет ещё одна подследовательность, то он прочитает и её.

rtvd ★★★★★ ()
Ответ на: комментарий от psikh

psikh, ты - глупец, троль и девственник. Топай в игнор, бенчмаркай там количество ангелов на острие иглы.

rtvd ★★★★★ ()
Ответ на: комментарий от anonymous

Почему нельзя просто ответить: все давно перешли на питон3, кроме нескольких маргинальных либ/все ждут когда все перейдут на питон3, поэтому все сидят на питон2/иной вариант ответа?

ugoday ★★★★★ ()
Ответ на: комментарий от rtvd

А время выполнения отдельных команд языка при схожей функциональности сойдут за тест на производительность?

anonymous ()
Ответ на: комментарий от ugoday

Почему нельзя просто ответить: все давно перешли на питон3, кроме нескольких маргинальных либ/все ждут когда все перейдут на питон3, поэтому все сидят на питон2/иной вариант ответа?

Иной вариант ответа.

anonymous ()
Ответ на: комментарий от rtvd

Видишь, они не вычисляют частоты а потом ищут среди результатов то, что нужно. Они вычисляют частоты для каждой из последовательностей отдельно.

Что-то я не уловил, в чем разница.

anonymous ()
Ответ на: комментарий от rtvd

Если SBCL уже не числится среди живых, то что тогда живо? CLIPS что-ли? :-)

Я не говорил, что sbcl не числится среди живых. Просто он при всех его достоинствах он славился своей недружелюбностью (по сравнению с CCL).

ЗЫ вроде ты выше описывал недостатки sbcl.

ados ★★★★★ ()
Ответ на: комментарий от anonymous

А время выполнения отдельных команд языка при схожей функциональности сойдут за тест на производительность?

Нет, только при полностью совпадающей семантике.

anonymous ()
Ответ на: комментарий от anonymous

Во-первых, ты смотришь на байткод, а он потом джитится все равно.

Из какашки даже JIT конфету не сделает.

Во-вторых, ты ж просто не понимаешь, о чем говоришь,

Да что вы такое говорите...

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

Вам пора премию давать за вклад в computer science.

Циклы разворачивать можно только в очень ограниченном числе случаев. Конкретно, решение должно приниматься с учётом CPU pipeline, кешей, и т.д. На этому уровне разворачивать циклы нельзя, это убивает производительность. Тем более, раворачивать их _таким диким образом_.

Ну и в-третьих - зачем тебе смотреть на компилированный код? Главное, что ты знаешь, что оно работает ну не медленнее того же SBCL. А уж как выглядит - дело десятое.

То, что оно работает на порядок медленнее чем SBCL я по-моему уже написал. К тому же, SBCL также не особо шустёр.

rtvd ★★★★★ ()
Ответ на: комментарий от rtvd

То, что оно работает на порядок медленнее чем SBCL я по-моему уже написал.

Странно, факты говорят обратное. Как показывают тесты, Racket работает наравне с SBCL, иногда чуть медленнее, иногда - чуть быстрее (зависит от конкретного теста).

Циклы разворачивать

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

Из какашки даже JIT конфету не сделает.

Не знаю, для меня эстетика сгенерированного кода никогда не была важна. Главное, чтобы работало шустро.

> Конкретно, решение должно приниматься с учётом CPU pipeline, кешей, и т.д.

На уровне генерации байткода нету никаких ЦПУ и прочего. Байткод пишется под виртуальную машину. При чем он очень высокоуровневый. Де-факто байткод - это просто фулл-экспандед код обычной ракеты. Соответственно и исполняется он на лисп-машине, а не на ЦПУ. С точки зрения этого байткода еще нет никакого ЦПУ, ЦПУ появляется уровнем ниже.

anonymous ()
Ответ на: комментарий от anonymous

Нет, только при полностью совпадающей семантике.

А что, бывают языки с полностью совпадающей семантикой программ, которые на них написаны?

anonymous ()
Ответ на: комментарий от anonymous

Странно, факты говорят обратное. Как показывают тесты, Racket работает наравне с SBCL, иногда чуть медленнее, иногда - чуть быстрее (зависит от конкретного теста).

Вызов пустой функции из .so через FFI на Racket занимает 150 наносекунд а на SBCL - 30. Но в любом случае это - соревнование в спец. олимпиаде, т.к. тратить на такой вызов более 5 наносекунд - верх неоптимальности.

Другие случаи даже не смотрел - уже стало не интересно.

Это инлайнинг, а не разворачивание циклов. Я же говорю - ты не понимаешь, о чем говоришь.

Угу, конечно. Инлайнинг чего делается в этом коде:

#lang racket/base

(define (foobar)
    (for ([i (in-range 1000000)])
        (print «hi»)))

Если получается такое уродство, так это:

...
((#%closed
  for-loop12
  (lambda (arg0-21 arg1-22)
    '#(for-loop
       #<path:/home/rtvd/src/rtvd-racket/test2/compiled/test.rkt>
       4
       4
       41
       51
       #f)
    '(flags: preserves-marks single-result)
    (if (unsafe-fx< arg1-22 '1000000)
      (begin
        (#%sfs-clear arg0-21)
        (begin
          (print '«hi»)
          (let ((local26 (unsafe-fx+ (#%sfs-clear arg1-22) '1)))
            (if (unsafe-fx< local26 '1000000)
              (begin
                (print '«hi»)
                (let ((local32
                       (unsafe-fx+ (#%sfs-clear local26) '1)))
                  (if (unsafe-fx< local32 '1000000)
                    (begin
                      (print '«hi»)
                      (let ((local38
                             (unsafe-fx+ (#%sfs-clear local32) '1)))
                        (if (unsafe-fx< local38 '1000000)
                          (begin
                            (print '«hi»)
                            (let ((local44
                                   (unsafe-fx+
                                    (#%sfs-clear local38)
                                    '1)))
                              (if (unsafe-fx< local44 '1000000)
                                (begin
                                  (print '«hi»)
                                  (for-loop12
                                   '#<void>
                                   (unsafe-fx+ local44 '1)))
                                '#<void>)))
                          '#<void>)))
                    '#<void>)))
              '#<void>))))
      arg0-21)))
 '#<void>
 '5)

И в чем смысл этого безумия?

В схеме нету циклов, там хвостовая рекурсия.

Чушь. В схеме полно циклов. Просто они _реализованны_ через хвостовую рекурсию.

Не знаю, для меня эстетика сгенерированного кода никогда не была важна. Главное, чтобы работало шустро.

В том то и дело, что работает _не_ шустро.

На уровне генерации байткода нету никаких ЦПУ и прочего. Байткод пишется под виртуальную машину. При чем он очень высокоуровневый. Де-факто байткод - это просто фулл-экспандед код обычной ракеты. Соответственно и исполняется он на лисп-машине, а не на ЦПУ. С точки зрения этого байткода еще нет никакого ЦПУ, ЦПУ появляется уровнем ниже.

Ты серьёзно считаешь, что сообщил мне что-то новое?

Вообще-то я тебе и пытался донести, что делать дурацкие «оптимизации» типа того, что делает racket, на уровне байткода - не только бессмысленно, но и вредно. Т.к. на этом уровне ещё не известна специфика машины.

rtvd ★★★★★ ()
Ответ на: комментарий от ugoday

Кто-то перешел на питон3, когда он еще был в стадии альфа-версии, кто-то подождал, пока мажорные либы появятся и перешел. Кто-то, вроде девелоперов меркуриала, до сих пор сидит на питоне2 и всем абсолютно доволен. Точную статистику тебе вряд ли кто-то скажет.

provaton ★★★★★ ()
Ответ на: комментарий от anonymous

А что, бывают языки с полностью совпадающей семантикой программ, которые на них написаны?

Я таких не знаю. но не буду утверждать, что таких языков нет.

anonymous ()
Ответ на: комментарий от rtvd

Вызов пустой функции из .so через FFI на Racket занимает 150 наносекунд а на SBCL - 30.

Ты же понимаешь что без конкретного кода это просто невнятное кукареканье? Что вызывалось? Как вызывалось?

т.к. тратить на такой вызов более 5 наносекунд - верх неоптимальности.

Ты забываешь про наличие рантайма. Так что в данном случае 100мс - может быть сверхпотимально. Учитывая, что Racket во время вызова FFI делает на порядок больше, чем SBCL, понятно, что и занимает этот вызов больше. Но без конкретного кода, повторяю, это просто кукареканье.

Это все не говоря о том, что вызов функции через ффи - весьма узкий тест, который производительность платформы никак не показывает.

Угу, конечно. Инлайнинг чего делается в этом коде:

Инлайнинг функции. for - это на самом деле нечто вроде (let loop ([...]) ... (loop)) - вот функция loop и инлайнится. Вообще говоря, это из кода совершенно ясно.

И в чем смысл этого безумия?

Я не понял вопроса. Что именно неясно?

Чушь. В схеме полно циклов. Просто они _реализованны_ через хвостовую рекурсию.

Именно так. Вот хвосторекурсивные вызовы и инлайнятся.

В том то и дело, что работает _не_ шустро.

Такого понятия как шустр оили не шустро в программировании нет. Есть «шустро для Х». Так вот не шустро _для чего_?

Вообще-то я тебе и пытался донести, что делать дурацкие «оптимизации» типа того, что делает racket, на уровне байткода - не только бессмысленно, но и вредно. Т.к. на этом уровне ещё не известна специфика машины.

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

anonymous ()
Ответ на: комментарий от rtvd

Ну и кстати 5 наносекунд - это несколько тактов процессора. У тебя сишка с такой скоростью свои же ф-и вызвать не сможет.

anonymous ()
Ответ на: комментарий от anonymous

Я таких не знаю. но не буду утверждать, что таких языков нет.

То есть и сравнивать ЯП с разной семантикой программ нельзя, так?

anonymous ()
Ответ на: комментарий от rtvd

У меня получилось:

(module test racket/base
  (#%module-begin
   (define-values (foobar)
     (lambda ()
       (let-values (((start) '0) ((end) (quote 1000000)) ((inc) '1))
         (if (if (#%app real? start) (if (#%app real? end) (#%app real? inc) '#f) '#f) (#%app void) (let-values () (#%app in-range start end inc)))
         (#%app
          (letrec-values (((for-loop)
                           (lambda (fold-var pos)
                             (if (#%app unsafe-fx< pos end)
                               (let-values (((i) pos))
                                 (if '#t
                                   (let-values (((fold-var)
                                                 (let-values (((fold-var) fold-var))
                                                   (let-values () (let-values () (#%app print (quote "hi"))) (#%app void)))))
                                     (if '#t (#%app for-loop fold-var (#%app unsafe-fx+ pos inc)) fold-var))
                                   fold-var))
                               fold-var))))
            for-loop)
          (#%app void)
          start))))))

qaqa ()
Ответ на: комментарий от qaqa

у тебя просто результат экспанда (то есть никакой компиляции нет), а у него decompile байткода.

anonymous ()
Ответ на: комментарий от rtvd

т.е. имеем представление, допустим с «оптимизацией» на срединном языке. Допустим, с некоторой точки зрения, такой код выглядит неоптимальным. Какое это имеет отношение к исполнению программы? Или важна именно эстетика срединного кода?

«Вызов пустой функции из .so через FFI на Racket занимает 150 наносекунд а на SBCL - 30. Но в любом случае это - соревнование в спец. олимпиаде, т.к. тратить на такой вызов более 5 наносекунд - верх неоптимальности.» - Вы судите об эффективности языка по скорости вызова пустой функции?

anonymous ()
Ответ на: комментарий от rtvd

Да, мне интересно, а во что по-твоему, _должен_ быть скомпилирован этот цикл, ну, в идеале?

anonymous ()
Ответ на: комментарий от anonymous

т.е. имеем представление, допустим с «оптимизацией» на срединном языке. Допустим, с некоторой точки зрения, такой код выглядит неоптимальным. Какое это имеет отношение к исполнению программы? Или важна именно эстетика срединного кода?

Прямое отношение.

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

«Вызов пустой функции из .so через FFI на Racket занимает 150 наносекунд а на SBCL - 30. Но в любом случае это - соревнование в спец. олимпиаде, т.к. тратить на такой вызов более 5 наносекунд - верх неоптимальности.» - Вы судите об эффективности языка по скорости вызова пустой функции?

Эффективность языка это вообще очень абстрактое понятие.

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

rtvd ★★★★★ ()
Ответ на: комментарий от rtvd

Он не просто выглядит неоптимальным. Он им является.

Это твое мнениЕ, которое к тому же ошибочно. Как из логических соображений (там сделаны вполне оптимальные оптимизации), так и из практических (производительность в итоге вполне reasonable).

о качестве реализации языка.

При чем тут «качество реализации языка»? Если тебе во время вызова надо сделать много работы, то ты хоть усрись, а он быстрым не будет. И тем более он не будет быстрее, чем вызов ф-и сишки в самой сишке (а сишка свои ф-и за 5 наносекунд вызывать не умеет, так что гцц, видимо, тоже очень некачественный компилятор, тормозной).

anonymous ()
Ответ на: комментарий от anonymous

Да, мне интересно, а во что по-твоему, _должен_ быть скомпилирован этот цикл, ну, в идеале?

что-то вроде

(define (foobar)
  (letrec ((do_loop (lambda (i)
    (if (< i 1000000)
      (begin
        (print «hi»)
        (do_loop (+ i 1)))
      #f))))
    (do_loop 0)))
rtvd ★★★★★ ()
Ответ на: комментарий от rtvd

Если вызов идёт быстро - это еще мало чего значит, но обнадёживает. Если идёт очень медленно - явно есть проблемы. И если их видно даже на таком элементарном примере, то сложные примеры смотреть вообще смысла нет.

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

anonymous ()
Ответ на: комментарий от rtvd

Он же и скомпилировался ровно в то, что ты тут написал - с поправкой на инлайнинг (что гарантированно не замедлит выполнение). Какие проблемы-то?

anonymous ()
Ответ на: комментарий от anonymous

Это твое мнениЕ, которое к тому же ошибочно. Как из логических соображений (там сделаны вполне оптимальные оптимизации), так и из практических (производительность в итоге вполне reasonable).

Где ты там увидел полезные оптимизации? Дональда Кнута на тебя нет.

При чем тут «качество реализации языка»? Если тебе во время вызова надо сделать много работы, то ты хоть усрись, а он быстрым не будет.

Ты пьян. Вызов ничего не делающей функции это не «много работы». Печать «hi» это тоже не дико много.

И тем более он не будет быстрее, чем вызов ф-и сишки в самой сишке (а сишка свои ф-и за 5 наносекунд вызывать не умеет, так что гцц, видимо, тоже очень некачественный компилятор, тормозной).

Лапочка, C вызывает эту функцию на той же самой машине за 3 наносекунды. Это быстрее чем racket в 50 раз. И быстрее SBCL в 10 раз.

Короче, если ты глухарь - иди лесом, заливайся дальше.

rtvd ★★★★★ ()
Ответ на: комментарий от anonymous

Он же и скомпилировался ровно в то, что ты тут написал - с поправкой на инлайнинг (что гарантированно не замедлит выполнение). Какие проблемы-то?

Какой к черту инлайнинг? Как это «гарантированно не замедлит выполнение»? Ты чё, с дуба рухнул?

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

rtvd ★★★★★ ()
Ответ на: комментарий от rtvd

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

anonymous ()
Ответ на: комментарий от rtvd

Какой к черту инлайнинг?

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

Как это «гарантированно не замедлит выполнение»?

Ты знаешь хоть одну реальную платформу, на которой функциональный вызов окажется быстрее (или хотя бы не медленнее) заинлайненого? Назови, пожалуйста.

anonymous ()
Ответ на: комментарий от anonymous

В год рублей?

Оклады в России как сумма в месяц измеряются.

Deleted ()
Ответ на: комментарий от rtvd

Где ты там увидел полезные оптимизации?

Да вот там и увидел. Инлайнинг.

Вызов ничего не делающей функции это не «много работы».

С точки зрения рантайма вызов ничего не делающей foreign функции совершенно не отличается от вызова любой другой foreign функции. И при любом таком вызове следует провести огромную подготовительную работу, чтобы рантайм не увалился.

Печать «hi» это тоже не дико много.

Печтьа «hi» - это вывод, то есть самое тормозное, что вообще можно придумать.

Лапочка, C вызывает эту функцию на той же самой машине за 3 наносекунды.

Естественно, ты не предоставишь код на сях и результат компиляции этого кода?

anonymous ()
Ответ на: комментарий от ugoday

Scheme, guile и lisp в разы лучше чем удав3. А для веба сейчас активно осваивается ruby on rails.

PS. Но мне интереснее Haskell и его применение к веб-разработке. Думаю опыт Erlang разработок представленных широко в сети будет полезен.

Deleted ()
Ответ на: комментарий от rtvd

[[т.е. имеем представление, допустим с «оптимизацией» на срединном языке. Допустим, с некоторой точки зрения, такой код выглядит неоптимальным. Какое это имеет отношение к исполнению программы? Или важна именно эстетика срединного кода?]]

[Прямое отношение.

Он не просто выглядит неоптимальным. Он им является. Если он изначально дико неоптимален, но надеяться на JIT будет только оптимист. А я - реалист.]

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

anonymous ()
Ответ на: комментарий от Deleted

Scheme, guile и lisp в разы лучше чем удав3

Но пишут в основном на удаве. Вот мазохисты.

anonymous ()
Ответ на: комментарий от anonymous

Да вот там и увидел. Инлайнинг.

И нахрена он там? Что он «улучшает» и как это у него получается?

С точки зрения рантайма вызов ничего не делающей foreign функции совершенно не отличается от вызова любой другой foreign функции. И при любом таком вызове следует провести огромную подготовительную работу, чтобы рантайм не увалился.

Офигительный объем подготовительной работы: подцепить ELF, найти в нём функцию и нацелить на неё указатель. Умора.

Печтьа «hi» - это вывод, то есть самое тормозное, что вообще можно придумать.

Печтьа «hi» там только для того, чтобы легче читать декомпильнутый байткод. В бенчмарке, естественно, запускалась ffi функция. Оригинальный код был таким:

#lang racket

(require
    ffi/unsafe
    ffi/unsafe/define)

(define-ffi-definer define-t (ffi-lib «libtest»))

(define-t do_test (_fun -> _void))

(define (do_benchmark)
    (time (for ([i (in-range 1000000)])
        (do_test))))

Естественно, ты не предоставишь код на сях и результат компиляции этого кода?

Код пустой функции (очевидно):

void do_test(void)
{}

Код вызывающей его программы (тоже очевидно):

extern void do_test(void);

int main(int argc, char **argv)
{
    for(long i = 0; i < 1000000000; i ++)
        do_test();
}

Результат я уже писал - 3 наносекунды на итерацию.

Дизассеблированный код красив и тривиален:

0000000000400540 <main>:
  400540:       53                      push   %rbx
  400541:       bb 00 ca 9a 3b          mov    $0x3b9aca00,%ebx
  400546:       66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
  40054d:       00 00 00 
  400550:       e8 db ff ff ff          callq  400530 <do_test@plt>
  400555:       48 83 eb 01             sub    $0x1,%rbx
  400559:       75 f5                   jne    400550 <main+0x10>
  40055b:       31 c0                   xor    %eax,%eax
  40055d:       5b                      pop    %rbx
  40055e:       c3                      retq   
  40055f:       90                      nop

А главное, быстр.

rtvd ★★★★★ ()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.