Ты идимо не понял, что имелась ввиду конструкция, когда дефолтное значение задается в прототипе.
WBR, Nick Tsigouro
Написал: ClaList(2)
OMITted параметры можно отследить
Модератор: Дед Пахом
Правила форума
При написании вопроса или обсуждении проблемы, не забывайте указывать версию Clarion который Вы используете.
А так же пользуйтесь спец. тегами при вставке исходников!!!
При написании вопроса или обсуждении проблемы, не забывайте указывать версию Clarion который Вы используете.
А так же пользуйтесь спец. тегами при вставке исходников!!!
-
Гость
Как раз именно так и понял. 
Поэтому и захотелось увидеть пример: что можно такого сделать при задаваемых
значениях по умолчанию в параметрах, что нельзя сделать при опускаемых параметрах?
Да собственно при перегрузке процедур - то же самое.
Единственное, когда нельзя обойтись без перегрузки проц.- это когда типы параметров разные. Но это особый, единственный случай.
Сергей
Написал: ClaList(2)
Поэтому и захотелось увидеть пример: что можно такого сделать при задаваемых
значениях по умолчанию в параметрах, что нельзя сделать при опускаемых параметрах?
Да собственно при перегрузке процедур - то же самое.
Единственное, когда нельзя обойтись без перегрузки проц.- это когда типы параметров разные. Но это особый, единственный случай.
Сергей
Написал: ClaList(2)
-
Гость
Про это я ничего не говорил. Думаю, что ничего, и даже меньше.Поэтому и захотелось увидеть пример: что можно такого сделать при задаваемых
значениях по умолчанию в параметрах, что нельзя сделать при опускаемых параметрах?
Перегрузка по функциональности богаче, чем дефолтные значения в прототипе, и эквивалентна анализу через OMITTED(), но имхо понятнее, а с учетом описанных проблем и не только понятнее, но и имеет более широкую область применения. Богаче уже тем, что не ограничена простыми числовыми типами и константами в качестве дефолтных значений. Так зачем пользовать два механизма там, где достаточно одного.Да собственно при перегрузке процедур - то же самое.
WBR, Nick Tsigouro
Написал: ClaList(2)
-
Гость
Procedure Overloading means allowing multiple PROCEDURE definitions to use the same name.Да ничего страшного, просто каждое средство для своей задачи. Если ты про производительность, то лишний call всяко проиграет "неявному if" и лишнему параметру в стеке.
This is one form of polymorphism. In order to allow this each PROCEDURE using a shared name must receive different parameters so the compiler can decide, based on the parameters passed which PROCEDURE to call.
The idea here is to allow more than one procedure of the same name, but with different prototypes, so separate (but usually similar) operations can occur on different data types. From an efficiency viewpoint, Procedure Overloading is _much__more__efficient__than__coding_a_single_procedure_with_omittable__parameters,
for those cases where you may or may not receive multiple parameters.
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
Написал: ClaList(2)
-
Гость
-
Гость
Владимир, ну и к чему эта цитата? Что собственно этой цитатой вы хотели сказать? Здесь что-нибудь сказано про лишний call? Здесь вообще нет речи о дополнительном вызове метода, о котором мы говорили.
Так что, мимо кассы
Удачи!
__________________________________
Владимир Якимченко
Написал: ClaList(2)
Так что, мимо кассы
Удачи!
__________________________________
Владимир Якимченко
Написал: ClaList(2)
-
Гость
Я бы сказал, что _much__more__efficient_ надо бы тестом доказать.From an efficiency viewpoint, Procedure Overloading is _much__more__efficient__than__coding_a_single_procedure_with_omitt able__parameters, for those cases where you may or may not receive multiple parameters.
Так если не экономить на объеме кода, а бороться за производительность, то вынося общий код в инклюдник, можно обойтись и без лишнего call. И тогда перегрузка выиграет в обоих сдучаях. И при наличии параметра и при отсутствии.Владимир, ну и к чему эта цитата? Что собственно этой цитатой вы хотели сказать? Здесь что-нибудь сказано про лишний call? Здесь вообще нет речи о дополнительном вызове метода, о котором мы говорили.
. Но я про эффективность помянул только в том отношении, что накладные расходы на перегрузку вообще минимальны. Об этом голова может не болеть.WBR, Nick Tsigouro
Написал: ClaList(2)
-
Гость
А давай вааще все процедуры вынесем в инклюдники. В борьбе за производительностьТак если не экономить на объеме кода, а бороться за производительность, то вынося общий код в инклюдник, можно обойтись и без лишнего call.
Тогда ни перегружать будет нечего, ни параметры умалчивать негде, а работать быстро буде-е-ет
Удачи!
__________________________________
Владимир Якимченко
Написал: ClaList(2)
-
Гость
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 16 октября 2004 г., 15:34:45
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Nick,
Friday, October 15, 2004, 10:08:32 AM, you wrote:
>> _much__more__efficient__than__coding_a_single_procedure_with_omitt
>> able__parameters,
>> > for those cases where you may or may not receive multiple parameters.
NT> Я бы сказал, что _much__more__efficient_ надо бы тестом доказать.
Тестом чего? Скорости исполнения или скорости написания?
Я то встрял в эту тему, потому как чуть раньше на эту фразу наткнулся,
когда раскручивал хелп для перевода.
И не могу причислить себя к знатокам этой темы. Но рад, что это
подогрело дискуссию. Как мне показалось, аргументы против перегрузки
звучали со стороны нелюбителей АВС.
Из своего опыта (небольшого)мне было удобно использовать
процедуру с опускаемыми параметрами в такой ситуации:
Процедура с параметрами используется в нескольких dll в проекте.
Возникла потребность изменить количество передаваемых ей параметров в
новой процедуре. Добавляю в конец списка параметров новый omitted
параметр и еду дальше, не исправляя коды в других dll. Как реализовать
это (без класса!) с перегрузкой - не знаю.
А при добавлениие методов шаблонов OfficeTemplates - мне удобней вариант с
перегрузкой.
>>
>> Владимир, ну и к чему эта цитата? Что собственно этой цитатой вы х
>> отели сказать? Здесь что-нибудь сказано про лишний
>> call? Здесь вообще нет речи о дополнительном вызове метода, о кото
>> ром мы говорили.
Мне так показалось, что спор из "С удивлением и досадой ..."перешел на преимущества
того или иного метода, а не о размере ассемблерного кода.
Однако ж доверие к тексту в цитате у меня осталось. К тому же говорить
об эффективности надо не только с позиции скорости исполнения программы,
но и с позиции скорости ее написания. Простота использования перегружаемых
процедур - это явный плюс. Количество рукописного текста "If omitted ... "
или "Case omitted .." в противоположном методе для меня - минус.
К чему это приводит в ассемблере, Вам виднее.
Основной вывод из этой дискуссии для меня следующий: большинство будет
складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
все же выбирать инструмент применительно к ситуации. Я так думаю...
Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
что-то новое(с перегружаемыми процедурами:-)).
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Олег А. Руденко <Oleg_Rudenko@mail.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 16:01:24
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {02}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте, Владимир!
суббота, 16 октября 2004 г., Вы писали:
В> Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
В> ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
В> что-то новое(с перегружаемыми процедурами:-)).
Да мне, честно говоря, "до лампочки" что использовать!
Я активно пользую и то и другое и не задумываюсь над
тем, насколько это эффективно или правильно (с точки зрения
теоретиков от программирования) в данном контексте -
просто ЛИЧНО МНЕ захотелось или показалось более
удобным использовать в данном месте именно этот вариант!
Единственное о чем жалко - что разработчики не дали
ЛЕГАЛЬНОГО способа обращения к параметрам по номеру.
Думаю, многие сталкивались с ситуацией, когда в списке
параметров указано много Omitted-параметров и хотелось-бы
использовать каждый параметр как элемент массива, типа:
Sum$ = 0
Loop Param# = 1 to ParamsCount()
if ~Omitted(Param#) then Sum$ += Params(Param#).
.
Ну, или что-то подобное.
Кстати, любители перезагрузки - в данном случае, имхо,
все-же удобно использовать обычный IF или CASE вместо
множества однотипных деклараций перегружаемой процедуры!?
=============================
С уважением, Олег А. Руденко.
Oleg_Rudenko@mail.ru
Oleg_Rudenko@mail333.com
Библиотека DynaLib
http://dynalib.narod.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vadim Sinyavskiy <vadim@softcreator.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 4:41:53
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Владимир,
Saturday, October 16, 2004, 7:34:45 AM, you wrote:
В> Hello Nick,
В> Friday, October 15, 2004, 10:08:32 AM, you wrote:
>>> _much__more__efficient__than__coding_a_single_procedure_with_omitt
>>> able__parameters,
>>> > for those cases where you may or may not receive multiple parameters.
NT>> Я бы сказал, что _much__more__efficient_ надо бы тестом доказать.
В> Тестом чего? Скорости исполнения или скорости написания?
А пошто тест-то городить? Достатачно адной таблэткы... Фу - отвлекся,
достаточно простого взгляда в отладчике на оператор OMITTED - как
сразу все станет ясно - этот оператор выливается в проверку крохотного
байтика на стеке - а конкретно в пару операторов cmp+je/jne для
подавляющего большиства случаев. Для справки - банальное присвоение
строк займет в десятки раз больше времени.
И кстати - частенько я даже не использую OMITTED - просто все равно
дальше в коде будет проверка на "пустоту" переданного значения
(значение-то всегда же передается - а часто переданное пустое занчение
эквивалентно пропущенному параметру по логике обработки).
Так что я слабо себе представляю реальную процедуру, где бы был смысл
заводить разговор про more efficient. А уже про much - так лучше бы
техписателям хелпа не позориться.
В> Я то встрял в эту тему, потому как чуть раньше на эту фразу наткнулся,
В> когда раскручивал хелп для перевода.
В> И не могу причислить себя к знатокам этой темы. Но рад, что это
В> подогрело дискуссию. Как мне показалось, аргументы против перегрузки
В> звучали со стороны нелюбителей АВС.
Видимо это камень в мой огород? А какая связь между нелюбви к ABC и
аргументации против тотального использования перегрузки методов?
Ну не пользую я ABC - но думаю что использую ООП гораздо больше и
интенсивнее, чем большинство пользвателей ABC - просто я пишу классы,
а не пользую чьи-то.
Кстати - перегрузку использую очень часто - когда _реально_ нужна
разная внутренняя логика обработки - но при этом внешнее назначение
методов идентично.
В> Однако ж доверие к тексту в цитате у меня осталось. К тому же говорить
В> об эффективности надо не только с позиции скорости исполнения программы,
В> но и с позиции скорости ее написания. Простота использования перегружаемых
В> процедур - это явный плюс. Количество рукописного текста "If omitted ... "
В> или "Case omitted .." в противоположном методе для меня - минус.
Это в смысле - море методов, каждый из которых отличатеся 2-я
строчками - плюс?! Свежо однако...
Ну и насчет частой уместности неиспользования оператора проверки пропускаемых
параметров - я уже писал выше.
В> К чему это приводит в ассемблере, Вам виднее.
см. выше.
В> Основной вывод из этой дискуссии для меня следующий: большинство будет
В> складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
В> все же выбирать инструмент применительно к ситуации. Я так думаю...
Большиство не будет вообще использовать перегрузку - ибо просто не
пишет классы
В> Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
В> ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
В> что-то новое(с перегружаемыми процедурами:-)).
P.S. Новое - не всегда лучше старого.
P.P.S. Консерваторы - люди, являющиеся цементом социума. Именно они
не позволяют обществу развалиться под воздействием новых идей.
--
Best regards,
Vadim mailto:vadim@softcreator.com
ICQ: 82308757
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@mail333.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 11:58:42
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Vadim Sinyavskiy
Так что я слабо себе представляю реальную процедуру, где бы был смысл
заводить разговор про more efficient. А уже про much - так лучше бы
техписателям хелпа не позориться.
Если уж быть честными до конца, то и будем
К скорости выполнения кода ВНУТРИ процедуры(метода) надо
прибавить ещё скорость вызова самой процедуры. Так вот,
вызов проц. без параметров заметно быстрее, чем вызов проц.
с параметрами, передаваемыми по адресу, и ещё быстрее чем
с параметрами, переданными по значению.
Когда-то я тестировал это. Конкретных цифр не помню уже, но в
памяти крепко засело, что хочешь скорости - пользуй без параметров.
Вот тебе и "much more efficient" И чем здоровее параметр, тем более "much" получишь
Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 8:14:46
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
Ну до чего же ты любишь, Сергей, говорить банальные истины порой. А потестировать банальные истины, так и хлебом не корми. Просто удивляюсь
Воспринимай как комлимент
"хочешь скорости - пользуй без параметров" звучит очень свежо, примерно как "хочешь скорости - катайся под горку", или "хочешь скорости - дави на газ, не дави на тормоз"
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
From: Чушкин Сергей
Если уж быть честными до конца, то и будем
К скорости выполнения кода ВНУТРИ процедуры(метода) надо
прибавить ещё скорость вызова самой процедуры. Так вот,
вызов проц. без параметров заметно быстрее, чем вызов проц.
с параметрами, передаваемыми по адресу, и ещё быстрее чем
с параметрами, переданными по значению.
Когда-то я тестировал это. Конкретных цифр не помню уже, но в
памяти крепко засело, что хочешь скорости - пользуй без параметров.
Вот тебе и "much more efficient" И чем здоровее параметр, тем более "much" получишь
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vadim Sinyavskiy <vadim@softcreator.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 18:07:38
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Чушкин,
Sunday, October 17, 2004, 3:58:42 AM, you wrote:
ЧС> Здравствуйте
ЧС> From: Vadim Sinyavskiy
ЧС> Так что я слабо себе представляю реальную процедуру, где бы был смысл
ЧС> заводить разговор про more efficient. А уже про much - так лучше бы
ЧС> техписателям хелпа не позориться.
ЧС> Если уж быть честными до конца, то и будем
ЧС> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС> с параметрами, переданными по значению.
ЧС> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС> Вот тебе и "much more efficient" И чем здоровее параметр, тем более "much" получишь
Хорошо - будем честными.
Рисуем тест:
PROGRAM
MAP
Test1(<STRING Str>)
Test2
END
LoopIndex LONG
CODE
Clock# = CLOCK()
LOOP LoopIndex = 1 TO 10000000
Test1()
END
T1# = CLOCK() - Clock#
Clock# = CLOCK()
LOOP LoopIndex = 1 TO 10000000
Test2()
END
T2# = CLOCK() - Clock#
STOP(T1# & ' *** ' & T2#)
RETURN
!-----------------------------------------------
Test1 PROCEDURE(<STRING Str>)
CODE
RETURN
!-----------------------------------------------
Test2 PROCEDURE
CODE
RETURN
!-----------------------------------------------
Прогоняем - получаем фантастический выигрыш вызов второй процедуры -
разница как минимум на порядок (а то и 14 раз)! Вот оно - "much more efficient"!!!
Потому чухаем репку приходим к мысли - а не оторвались ли мы от народа
с таким тестом? Народу нужны реалистичные тесты - и модифицируем тела
обеих процедур:
C LONG,AUTO
A LONG,AUTO
B LONG,AUTO
CODE
C = A + B
получаем фантастическую по насыщенности кода процедуру и тестируем ее.
Теперь запуск показывает, что теперь выигрышь составляет только раза 4.
Идем дальше - декларируем коротенькую строку S STRING(20),AUTO и
добавляем просто инициализацию S = '1234567890', балдеем от возрошего
функционала тестовых процедур - но после запуска обнаруживаем, что
выигрыш теперь сократился до 40 процентов.
Какое отношение эти тесты имеют к реальным процедурам? Да никакого!
Потому что:
1. В тесте нет никакого функционала - процедуры _абсолютно_ голые.
2. В тесте каждая их них вызывается 10 миллионов раз - только при
таком числе повторе можно обсуждать разницу "голого" вызова.
Итак - велосипидистам можно было бы сказать - "мы способны написать
лабораторные тесты, в которых перегрузка даст значительный выигрыш
по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
С такой формулировкой я был бы абсолютно согласен.
А так, пардон - но банальный обман. Типа анализа роста благосостояния
советских семей на основне роста количества телевизоров в семьях
по сравнению с 1913 годом - в приницпе все правда, но к реалиям
никакого отношения не имеет.
ЧС> Сергей - chusha@mail333.com ; chusha@hotbox.ru
--
Best regards,
Vadim mailto:vadim@softcreator.com
ICQ: 82308757
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 8:37:11
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
From: "Vadim Sinyavskiy" <vadim@softcreator.com>
> Итак - велосипидистам можно было бы сказать - "мы способны написать
> лабораторные тесты, в которых перегрузка даст значительный выигрыш
> по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
> С такой формулировкой я был бы абсолютно согласен.
Не, Вадим. Тут ты не прав. Твой первый тест был чистым и тестировал именно скорость _вызова_процедуры_. То есть именно
то, о чем говорил Сергей, "процедура без параметров запускается быстрее процедуры с параметрами". Все дальнейшие твои
действия только вносили погрешность, все более существенную, в экспериментальные данные. И приближение к практическому
использованию тут уж совсем не при чем, очевидно что практическая польза от такого скоростного вызова процедуры без
параметра ничтожна (исключение - вызов с большим строковым параметром по значению).
Ну это же очевидные вещи, их и тестировать нет смысла, и лежат они совсем в стороне от subj
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@t50.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 2:12:08
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Vadim Sinyavskiy
Итак - велосипидистам можно было бы сказать - "мы способны написать
лабораторные тесты, в которых перегрузка даст значительный выигрыш
по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
С такой формулировкой я был бы абсолютно согласен.
Ох и дотошный ты товарищъ, мистер Вадим!)
Применяется. И применяется в реальном коде.
Я же в самом первом письме привёл два метода.
ErrCode даёт фактический выигрыш от перегрузки, а Next не даёт.
Да ты и сам можешь привести кучу примеров, где перегрузка даст ускорение работы.
Для тестов могу предложить вариант, где пожалуй вообще не заметишь разницы)
gXYZType group, type
eX real
eY real
eZ real
end
.....
min like(gXYZType)
code
clear(XYZ, 1)
...
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 9:30:04
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html, Test.clw
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
From: Чушкин Сергей
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Давайте же сформулируем КОНКРЕТНЫЕ условия и проведем наконец тест, чтоб определиться что же все таки эффективней. Итак, конкретные условия для задачи с опускаемым параметром и со значением по умолчанию, которая изначально (в общих чертах) обсуждалась с Николаем Цигуро.
Есть класс, у класса есть свойство, это свойство надо инициализировать. Инициализация осуществляется методом класса с параметром. При инициализации параметр может быть опущен, в этом случае используется значение по умолчанию. Все согласны с условиями? Теперь подумаем, кто как решил бы подобную задачу.
Предлагается два варианта (предположим строковый параметр)
1. через перегрузку методов
ClassStr1 CLASS
MyProp STRING(50)
MyProcStr1 PROCEDURE
MyProcStr1 PROCEDURE(STRING MyString)
END
!***********************************
ClassStr1.MyProcStr1 PROCEDURE
CODE
SELF.MyProcStr1('DEFAULT')
!***********************************
ClassStr1.MyProcStr1 PROCEDURE(STRING MyString)
CODE
SELF.MyProp = MyString
!***********************************
1. через OMITTED
ClassStr2 CLASS
MyProp STRING(50)
MyProcStr2 PROCEDURE(<STRING MyString>)
END
!***********************************
ClassStr2.MyProcStr2 PROCEDURE(<STRING MyString>)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyString.
!***********************************
Постараемся оценить эти решения с точки зрения эффективности кода (скорости выполнения). Об эффективности стиля программирования в данном случае можно много и бесплодно спорить.
Тест во вложении, вот результаты, полученные на моей машине:
1. Строка. Перегрузка (423) , OMITTED(271)
2. Число. Перегрузка (6) , OMITTED(3)
Итак, для этой (на мой взгляд стандартной) задачи использование OMITTED более эффективно.
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Дуга Михаил <mikeduglas@intercare.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 9:42:51
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Владимир!
из вложения:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyLong.
!***********************************
тут long SELF.MyProp='DEFAULT', может на результат повлиять.
С уважением, Михаил
----- Original Message -----
From: Vladimir Yakimchenko
To:clalist List Member
Sent: Monday, October 18, 2004 9:30 AM
Subject: Re: Re[7]: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Привет, Всем!
From: Чушкин Сергей
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Давайте же сформулируем КОНКРЕТНЫЕ условия и проведем наконец тест, чтоб определиться что же все таки эффективней. Итак, конкретные условия для задачи с опускаемым параметром и со значением по умолчанию, которая изначально (в общих чертах) обсуждалась с Николаем Цигуро.
Есть класс, у класса есть свойство, это свойство надо инициализировать. Инициализация осуществляется методом класса с параметром. При инициализации параметр может быть опущен, в этом случае используется значение по умолчанию. Все согласны с условиями? Теперь подумаем, кто как решил бы подобную задачу.
Предлагается два варианта (предположим строковый параметр)
1. через перегрузку методов
ClassStr1 CLASS
MyProp STRING(50)
MyProcStr1 PROCEDURE
MyProcStr1 PROCEDURE(STRING MyString)
END
!***********************************
ClassStr1.MyProcStr1 PROCEDURE
CODE
SELF.MyProcStr1('DEFAULT')
!***********************************
ClassStr1.MyProcStr1 PROCEDURE(STRING MyString)
CODE
SELF.MyProp = MyString
!***********************************
1. через OMITTED
ClassStr2 CLASS
MyProp STRING(50)
MyProcStr2 PROCEDURE(<STRING MyString>)
END
!***********************************
ClassStr2.MyProcStr2 PROCEDURE(<STRING MyString>)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyString.
!***********************************
Постараемся оценить эти решения с точки зрения эффективности кода (скорости выполнения). Об эффективности стиля программирования в данном случае можно много и бесплодно спорить.
Тест во вложении, вот результаты, полученные на моей машине:
1. Строка. Перегрузка (423) , OMITTED(271)
2. Число. Перегрузка (6) , OMITTED(3)
Итак, для этой (на мой взгляд стандартной) задачи использование OMITTED более эффективно.
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 10:11:37
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
Пардон, сделал под копирку и ошибся. Правильно, конечно так:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
SELF.MyProp = MyLong
!***********************************
Но на результат это не повлияло (Перегрузка (6), OMITTED (3)), что лишний раз доказывает, что время выполнения if, по сравнению с конструкцией выполнения дополнительного метода, ничтожно.
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
----- Original Message -----
From: Дуга Михаил
To:clalist List Member
Sent: Monday, October 18, 2004 10:42 AM
Subject: Re: Re[7]: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Привет, Владимир!
из вложения:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyLong.
!***********************************
тут long SELF.MyProp='DEFAULT', может на результат повлиять.
С уважением, Михаил
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 1:43:27
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Vadim,
Sunday, October 17, 2004, 5:07:38 PM, you wrote:
VS> Hello Чушкин,
VS> Sunday, October 17, 2004, 3:58:42 AM, you wrote:
ЧС>> Здравствуйте
ЧС>> From: Vadim Sinyavskiy
ЧС>> Так что я слабо себе представляю реальную процедуру, где бы был смысл
ЧС>> заводить разговор про more efficient. А уже про much - так лучше бы
ЧС>> техписателям хелпа не позориться.
ЧС>> Если уж быть честными до конца, то и будем
ЧС>> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС>> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС>> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС>> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС>> с параметрами, переданными по значению.
ЧС>> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС>> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС>> Вот тебе и "much more efficient" И чем здоровее параметр, тем более "much" получишь
VS> Хорошо - будем честными.
VS> Рисуем тест:
VS> PROGRAM
VS> MAP
VS> Test1(<STRING Str>)
VS> Test2
VS> END
VS> LoopIndex LONG
VS> CODE
VS> Clock# = CLOCK()
VS> LOOP LoopIndex = 1 TO 10000000
VS> Test1()
VS> END
VS> T1# = CLOCK() - Clock#
VS> Clock# = CLOCK()
VS> LOOP LoopIndex = 1 TO 10000000
VS> Test2()
VS> END
VS> T2# = CLOCK() - Clock#
VS> STOP(T1# & ' *** ' & T2#)
VS> RETURN
VS> !-----------------------------------------------
VS> Test1 PROCEDURE(<STRING Str>)
VS> CODE
VS> RETURN
VS> !-----------------------------------------------
VS> Test2 PROCEDURE
VS> CODE
VS> RETURN
VS> !-----------------------------------------------
VS> Прогоняем - получаем фантастический выигрыш вызов второй процедуры -
VS> разница как минимум на порядок (а то и 14 раз)! Вот оно - "much more efficient"!!!
VS> Потому чухаем репку приходим к мысли - а не оторвались ли мы от народа
VS> с таким тестом? Народу нужны реалистичные тесты - и модифицируем тела
VS> обеих процедур:
VS> C LONG,AUTO
VS> A LONG,AUTO
VS> B LONG,AUTO
VS> CODE
VS> C = A + B
VS> получаем фантастическую по насыщенности кода процедуру и тестируем ее.
VS> Теперь запуск показывает, что теперь выигрышь составляет только раза 4.
VS> Идем дальше - декларируем коротенькую строку S STRING(20),AUTO и
VS> добавляем просто инициализацию S = '1234567890', балдеем от возрошего
VS> функционала тестовых процедур - но после запуска обнаруживаем, что
VS> выигрыш теперь сократился до 40 процентов.
VS> Какое отношение эти тесты имеют к реальным процедурам? Да никакого!
VS> Потому что:
VS> 1. В тесте нет никакого функционала - процедуры _абсолютно_ голые.
VS> 2. В тесте каждая их них вызывается 10 миллионов раз - только при
VS> таком числе повторе можно обсуждать разницу "голого" вызова.
Наверное тесты еще зависят от машин. Здесь старый Celeron633 и 128Мб
под w2k
test1/test2 =
419****16 =26.185 !на вашей 14
423****26 =16.269 !-"= 4
692****274 = 2.526 !-"= 0,4
Если посмотреть диспетчером задач на загрузку процессора, то при
вызове test1 время ядра подпрыгивает от 30 в 1-м случае до 10 в 3-м.
test2 вообще не вызывает изменение этого параметра.
Что же, мораль все же есть. Если придется использовать процедуры с
"голым функционалом" по 10 млн раз - буду знать что предпочтительнее.
А вообще-то "зацепились" в последний раз за то, что быстрее вызывается,
а не за внутреннюю функциональность. Если увеличить количество
параметров скажем до 6, то разрыв будет еще больше.
по третьему"функционалу": 2736 ***1677 = 1,63
При этом test2 вызывался _6_ раз, что по жизни не всегда бывает.
Или MyOpen(File) Или MyOpen(File,PassWord)
Да и содержание при полной функциональности в случае с передаваемыми
параметрами, мне кажется, в большинстве случаев будет более
насыщенным. Программист часто старается построить что-то
универсальное( "два в одном" и более). Машина будет бегать по ветвям
этой многофункциональной процедуры поболее, чем при прямом вызове
коротких перегружаемых процедур. И читать мне текст последних
легче.Когда-то читал, что если текст процедуры занимает более 2-х
экранов, то это плохо написанная программа. Только не помню кто. То ли
паскалев папа, то ли из старых книг по С. А тогда экран был.. Ну,
вобщем помните...
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Олег А. Руденко <Oleg_Rudenko@mail.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 16:13:40
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {02}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте, Чушкин!
воскресенье, 17 октября 2004 г., Вы писали:
ЧС> Если уж быть честными до конца, то и будем
ЧС> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС> с параметрами, переданными по значению.
ЧС> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС> Вот тебе и "much more efficient" И чем здоровее параметр, тем более "much" получишь
Добавлю еще - первые omitted-параметры занимают регистры
для своих флажков. И остальные параметры передаются уже
через стек. А стек размещается в обычной памяти, которая
на порядок (на несколько?) медленнее процессорного регистра.
Это - не в упрек кому-либо!
Просто - если уж "... быть честными до конца ...",
то надо упомянуть обо всем.
=============================
С уважением, Олег А. Руденко.
Oleg_Rudenko@mail.ru
Oleg_Rudenko@mail333.com
Библиотека DynaLib
http://dynalib.narod.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@mail333.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 0:40:14
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Владимир
[Кусь]
Как мне показалось, аргументы против перегрузки
звучали со стороны нелюбителей АВС.
[Кусь]
Меня тоже к ним причислил?))
[Кусь]
Основной вывод из этой дискуссии для меня следующий: большинство будет
складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
все же выбирать инструмент применительно к ситуации. Я так думаю...
Правильно думаешь. Принципиальной разницы в способах нет, хотя теоретически
перегрузка методов работает быстрее. Но за всё нужно платить...
Мой опыт показывает что можно и нужно применять оба способа.
Обычно (обычно!) перегрузку применяю когда код сильно разнится в зависимости
от наличия или нет параметра. Или когда важны и проценты скорости выполнения.
Если объём кода приличный (десятки строк и более), а анализ параметра меняет
одну строку кода (или несколько), то использую пропуск. Обычно в этом коде
время на анализ пропущенного параметра составляет от сотых и менее долей
времени выполнения всего кода.
Например,
раньше я использовал метод ErrCode с пропуском параметра
i2Error.ErrCode procedure(<signed parErrorcode>)
сейчас использую с перегрузкой
i3Error.ErrCode procedure
i3Error.ErrCode procedure(signed parErrorcode)
т.к. этот метод используется везде, где только можно и уже стала важна скорость его вызова.
Другой случай - метод
i3RTL.Next procedure(*queue parQ, <signed parPointer>, signed parFlag=0)
здесь нет смысла делать перегрузку, т.к. код будет отличаться только одной строкой (из двух десятков)
if omitted(parPointer) then parPointer = pointer(parQ) end
плюс к тому же в этом методе оператор
get(parQ, parPointer)
на два порядка медленнее чем анализ пропуска параметра. Плюс вызов других методов, а
вызов любого метода (Процедуры) также медленнен как и GET.
p.s.
Я уже не помню с чего начали, но спор что "круче" в данном вопросе мне тоже не понятен :/
Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 0:03:38
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Чушкин,
Saturday, October 16, 2004, 11:40:14 PM, you wrote:
ЧС> Как мне показалось, аргументы против перегрузки
ЧС> звучали со стороны нелюбителей АВС.
ЧС> Меня тоже к ним причислил?))
ЧС> Сергей - chusha@mail333.com ; chusha@hotbox.ru
Да нет. Никого ни к кому не причислил. Я ж не совсем круглый ( далее
по выбору). Просто захотелось немножко подзавести народ. Как Тимур Вас
с тетками купил. (А я не полез: Чукча умный, чукча Тимура знает..) К
тому же я думаю, что это готовый кусок для будущего хелпа , если
вырезать некоторые личностные моменты. Вот Вадим даже тест-пример
сделал и не полез за своей дежурной базукой. Никто из третьей лиги не
сомневается в вашей квалификации, но как Вас заставить поделться
своими познаниями? Ведь еще 250 человек сидят за своими мониками и с
благодарностью внимают.
К тому ж когда еще грандам отмстишь за их бесконечные : "Все в RTFM!"
)
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Написал: ClaList(2)
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 16 октября 2004 г., 15:34:45
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Nick,
Friday, October 15, 2004, 10:08:32 AM, you wrote:
>> _much__more__efficient__than__coding_a_single_procedure_with_omitt
>> able__parameters,
>> > for those cases where you may or may not receive multiple parameters.
NT> Я бы сказал, что _much__more__efficient_ надо бы тестом доказать.
Тестом чего? Скорости исполнения или скорости написания?
Я то встрял в эту тему, потому как чуть раньше на эту фразу наткнулся,
когда раскручивал хелп для перевода.
И не могу причислить себя к знатокам этой темы. Но рад, что это
подогрело дискуссию. Как мне показалось, аргументы против перегрузки
звучали со стороны нелюбителей АВС.
Из своего опыта (небольшого)мне было удобно использовать
процедуру с опускаемыми параметрами в такой ситуации:
Процедура с параметрами используется в нескольких dll в проекте.
Возникла потребность изменить количество передаваемых ей параметров в
новой процедуре. Добавляю в конец списка параметров новый omitted
параметр и еду дальше, не исправляя коды в других dll. Как реализовать
это (без класса!) с перегрузкой - не знаю.
А при добавлениие методов шаблонов OfficeTemplates - мне удобней вариант с
перегрузкой.
>>
>> Владимир, ну и к чему эта цитата? Что собственно этой цитатой вы х
>> отели сказать? Здесь что-нибудь сказано про лишний
>> call? Здесь вообще нет речи о дополнительном вызове метода, о кото
>> ром мы говорили.
Мне так показалось, что спор из "С удивлением и досадой ..."перешел на преимущества
того или иного метода, а не о размере ассемблерного кода.
Однако ж доверие к тексту в цитате у меня осталось. К тому же говорить
об эффективности надо не только с позиции скорости исполнения программы,
но и с позиции скорости ее написания. Простота использования перегружаемых
процедур - это явный плюс. Количество рукописного текста "If omitted ... "
или "Case omitted .." в противоположном методе для меня - минус.
К чему это приводит в ассемблере, Вам виднее.
Основной вывод из этой дискуссии для меня следующий: большинство будет
складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
все же выбирать инструмент применительно к ситуации. Я так думаю...
Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
что-то новое(с перегружаемыми процедурами:-)).
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Олег А. Руденко <Oleg_Rudenko@mail.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 16:01:24
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {02}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте, Владимир!
суббота, 16 октября 2004 г., Вы писали:
В> Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
В> ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
В> что-то новое(с перегружаемыми процедурами:-)).
Да мне, честно говоря, "до лампочки" что использовать!
Я активно пользую и то и другое и не задумываюсь над
тем, насколько это эффективно или правильно (с точки зрения
теоретиков от программирования) в данном контексте -
просто ЛИЧНО МНЕ захотелось или показалось более
удобным использовать в данном месте именно этот вариант!
Единственное о чем жалко - что разработчики не дали
ЛЕГАЛЬНОГО способа обращения к параметрам по номеру.
Думаю, многие сталкивались с ситуацией, когда в списке
параметров указано много Omitted-параметров и хотелось-бы
использовать каждый параметр как элемент массива, типа:
Sum$ = 0
Loop Param# = 1 to ParamsCount()
if ~Omitted(Param#) then Sum$ += Params(Param#).
.
Ну, или что-то подобное.
Кстати, любители перезагрузки - в данном случае, имхо,
все-же удобно использовать обычный IF или CASE вместо
множества однотипных деклараций перегружаемой процедуры!?
=============================
С уважением, Олег А. Руденко.
Oleg_Rudenko@mail.ru
Oleg_Rudenko@mail333.com
Библиотека DynaLib
http://dynalib.narod.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vadim Sinyavskiy <vadim@softcreator.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 4:41:53
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Владимир,
Saturday, October 16, 2004, 7:34:45 AM, you wrote:
В> Hello Nick,
В> Friday, October 15, 2004, 10:08:32 AM, you wrote:
>>> _much__more__efficient__than__coding_a_single_procedure_with_omitt
>>> able__parameters,
>>> > for those cases where you may or may not receive multiple parameters.
NT>> Я бы сказал, что _much__more__efficient_ надо бы тестом доказать.
В> Тестом чего? Скорости исполнения или скорости написания?
А пошто тест-то городить? Достатачно адной таблэткы... Фу - отвлекся,
достаточно простого взгляда в отладчике на оператор OMITTED - как
сразу все станет ясно - этот оператор выливается в проверку крохотного
байтика на стеке - а конкретно в пару операторов cmp+je/jne для
подавляющего большиства случаев. Для справки - банальное присвоение
строк займет в десятки раз больше времени.
И кстати - частенько я даже не использую OMITTED - просто все равно
дальше в коде будет проверка на "пустоту" переданного значения
(значение-то всегда же передается - а часто переданное пустое занчение
эквивалентно пропущенному параметру по логике обработки).
Так что я слабо себе представляю реальную процедуру, где бы был смысл
заводить разговор про more efficient. А уже про much - так лучше бы
техписателям хелпа не позориться.
В> Я то встрял в эту тему, потому как чуть раньше на эту фразу наткнулся,
В> когда раскручивал хелп для перевода.
В> И не могу причислить себя к знатокам этой темы. Но рад, что это
В> подогрело дискуссию. Как мне показалось, аргументы против перегрузки
В> звучали со стороны нелюбителей АВС.
Видимо это камень в мой огород? А какая связь между нелюбви к ABC и
аргументации против тотального использования перегрузки методов?
Ну не пользую я ABC - но думаю что использую ООП гораздо больше и
интенсивнее, чем большинство пользвателей ABC - просто я пишу классы,
а не пользую чьи-то.
Кстати - перегрузку использую очень часто - когда _реально_ нужна
разная внутренняя логика обработки - но при этом внешнее назначение
методов идентично.
В> Однако ж доверие к тексту в цитате у меня осталось. К тому же говорить
В> об эффективности надо не только с позиции скорости исполнения программы,
В> но и с позиции скорости ее написания. Простота использования перегружаемых
В> процедур - это явный плюс. Количество рукописного текста "If omitted ... "
В> или "Case omitted .." в противоположном методе для меня - минус.
Это в смысле - море методов, каждый из которых отличатеся 2-я
строчками - плюс?! Свежо однако...
Ну и насчет частой уместности неиспользования оператора проверки пропускаемых
параметров - я уже писал выше.
В> К чему это приводит в ассемблере, Вам виднее.
см. выше.
В> Основной вывод из этой дискуссии для меня следующий: большинство будет
В> складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
В> все же выбирать инструмент применительно к ситуации. Я так думаю...
Большиство не будет вообще использовать перегрузку - ибо просто не
пишет классы
В> Еще что показательно: О.Руденко дал, по-моему, вполне исчерпывающий
В> ответ и в дальнейшую перепалку ввязываться не стал. Наверняка пишет
В> что-то новое(с перегружаемыми процедурами:-)).
P.S. Новое - не всегда лучше старого.
P.P.S. Консерваторы - люди, являющиеся цементом социума. Именно они
не позволяют обществу развалиться под воздействием новых идей.
--
Best regards,
Vadim mailto:vadim@softcreator.com
ICQ: 82308757
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@mail333.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 11:58:42
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Vadim Sinyavskiy
Так что я слабо себе представляю реальную процедуру, где бы был смысл
заводить разговор про more efficient. А уже про much - так лучше бы
техписателям хелпа не позориться.
Если уж быть честными до конца, то и будем
К скорости выполнения кода ВНУТРИ процедуры(метода) надо
прибавить ещё скорость вызова самой процедуры. Так вот,
вызов проц. без параметров заметно быстрее, чем вызов проц.
с параметрами, передаваемыми по адресу, и ещё быстрее чем
с параметрами, переданными по значению.
Когда-то я тестировал это. Конкретных цифр не помню уже, но в
памяти крепко засело, что хочешь скорости - пользуй без параметров.
Вот тебе и "much more efficient"
И чем здоровее параметр, тем более "much" получишь Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 8:14:46
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
Ну до чего же ты любишь, Сергей, говорить банальные истины порой. А потестировать банальные истины, так и хлебом не корми. Просто удивляюсь
Воспринимай как комлимент
"хочешь скорости - пользуй без параметров" звучит очень свежо, примерно как "хочешь скорости - катайся под горку", или "хочешь скорости - дави на газ, не дави на тормоз"
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
From: Чушкин Сергей
Если уж быть честными до конца, то и будем
К скорости выполнения кода ВНУТРИ процедуры(метода) надо
прибавить ещё скорость вызова самой процедуры. Так вот,
вызов проц. без параметров заметно быстрее, чем вызов проц.
с параметрами, передаваемыми по адресу, и ещё быстрее чем
с параметрами, переданными по значению.
Когда-то я тестировал это. Конкретных цифр не помню уже, но в
памяти крепко засело, что хочешь скорости - пользуй без параметров.
Вот тебе и "much more efficient"
И чем здоровее параметр, тем более "much" получишь =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vadim Sinyavskiy <vadim@softcreator.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 18:07:38
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Чушкин,
Sunday, October 17, 2004, 3:58:42 AM, you wrote:
ЧС> Здравствуйте
ЧС> From: Vadim Sinyavskiy
ЧС> Так что я слабо себе представляю реальную процедуру, где бы был смысл
ЧС> заводить разговор про more efficient. А уже про much - так лучше бы
ЧС> техписателям хелпа не позориться.
ЧС> Если уж быть честными до конца, то и будем
ЧС> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС> с параметрами, переданными по значению.
ЧС> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС> Вот тебе и "much more efficient"
И чем здоровее параметр, тем более "much" получишь Хорошо - будем честными.
Рисуем тест:
PROGRAM
MAP
Test1(<STRING Str>)
Test2
END
LoopIndex LONG
CODE
Clock# = CLOCK()
LOOP LoopIndex = 1 TO 10000000
Test1()
END
T1# = CLOCK() - Clock#
Clock# = CLOCK()
LOOP LoopIndex = 1 TO 10000000
Test2()
END
T2# = CLOCK() - Clock#
STOP(T1# & ' *** ' & T2#)
RETURN
!-----------------------------------------------
Test1 PROCEDURE(<STRING Str>)
CODE
RETURN
!-----------------------------------------------
Test2 PROCEDURE
CODE
RETURN
!-----------------------------------------------
Прогоняем - получаем фантастический выигрыш вызов второй процедуры -
разница как минимум на порядок (а то и 14 раз)! Вот оно - "much more efficient"!!!
Потому чухаем репку приходим к мысли - а не оторвались ли мы от народа
с таким тестом? Народу нужны реалистичные тесты - и модифицируем тела
обеих процедур:
C LONG,AUTO
A LONG,AUTO
B LONG,AUTO
CODE
C = A + B
получаем фантастическую по насыщенности кода процедуру и тестируем ее.
Теперь запуск показывает, что теперь выигрышь составляет только раза 4.
Идем дальше - декларируем коротенькую строку S STRING(20),AUTO и
добавляем просто инициализацию S = '1234567890', балдеем от возрошего
функционала тестовых процедур - но после запуска обнаруживаем, что
выигрыш теперь сократился до 40 процентов.
Какое отношение эти тесты имеют к реальным процедурам? Да никакого!
Потому что:
1. В тесте нет никакого функционала - процедуры _абсолютно_ голые.
2. В тесте каждая их них вызывается 10 миллионов раз - только при
таком числе повторе можно обсуждать разницу "голого" вызова.
Итак - велосипидистам можно было бы сказать - "мы способны написать
лабораторные тесты, в которых перегрузка даст значительный выигрыш
по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
С такой формулировкой я был бы абсолютно согласен.
А так, пардон - но банальный обман. Типа анализа роста благосостояния
советских семей на основне роста количества телевизоров в семьях
по сравнению с 1913 годом - в приницпе все правда, но к реалиям
никакого отношения не имеет.
ЧС> Сергей - chusha@mail333.com ; chusha@hotbox.ru
--
Best regards,
Vadim mailto:vadim@softcreator.com
ICQ: 82308757
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 8:37:11
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
From: "Vadim Sinyavskiy" <vadim@softcreator.com>
> Итак - велосипидистам можно было бы сказать - "мы способны написать
> лабораторные тесты, в которых перегрузка даст значительный выигрыш
> по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
> С такой формулировкой я был бы абсолютно согласен.
Не, Вадим. Тут ты не прав. Твой первый тест был чистым и тестировал именно скорость _вызова_процедуры_. То есть именно
то, о чем говорил Сергей, "процедура без параметров запускается быстрее процедуры с параметрами". Все дальнейшие твои
действия только вносили погрешность, все более существенную, в экспериментальные данные. И приближение к практическому
использованию тут уж совсем не при чем, очевидно что практическая польза от такого скоростного вызова процедуры без
параметра ничтожна (исключение - вызов с большим строковым параметром по значению).
Ну это же очевидные вещи, их и тестировать нет смысла, и лежат они совсем в стороне от subj
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@t50.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 2:12:08
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Vadim Sinyavskiy
Итак - велосипидистам можно было бы сказать - "мы способны написать
лабораторные тесты, в которых перегрузка даст значительный выигрыш
по времени. При использовании в реальном коде выигрыша НИКАКОГО НЕТ"
С такой формулировкой я был бы абсолютно согласен.
Ох и дотошный ты товарищъ, мистер Вадим!
)Применяется. И применяется в реальном коде.
Я же в самом первом письме привёл два метода.
ErrCode даёт фактический выигрыш от перегрузки, а Next не даёт.
Да ты и сам можешь привести кучу примеров, где перегрузка даст ускорение работы.
Для тестов могу предложить вариант, где пожалуй вообще не заметишь разницы
)gXYZType group, type
eX real
eY real
eZ real
end
.....
min like(gXYZType)
code
clear(XYZ, 1)
...
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 9:30:04
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html, Test.clw
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
From: Чушкин Сергей
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Давайте же сформулируем КОНКРЕТНЫЕ условия и проведем наконец тест, чтоб определиться что же все таки эффективней. Итак, конкретные условия для задачи с опускаемым параметром и со значением по умолчанию, которая изначально (в общих чертах) обсуждалась с Николаем Цигуро.
Есть класс, у класса есть свойство, это свойство надо инициализировать. Инициализация осуществляется методом класса с параметром. При инициализации параметр может быть опущен, в этом случае используется значение по умолчанию. Все согласны с условиями? Теперь подумаем, кто как решил бы подобную задачу.
Предлагается два варианта (предположим строковый параметр)
1. через перегрузку методов
ClassStr1 CLASS
MyProp STRING(50)
MyProcStr1 PROCEDURE
MyProcStr1 PROCEDURE(STRING MyString)
END
!***********************************
ClassStr1.MyProcStr1 PROCEDURE
CODE
SELF.MyProcStr1('DEFAULT')
!***********************************
ClassStr1.MyProcStr1 PROCEDURE(STRING MyString)
CODE
SELF.MyProp = MyString
!***********************************
1. через OMITTED
ClassStr2 CLASS
MyProp STRING(50)
MyProcStr2 PROCEDURE(<STRING MyString>)
END
!***********************************
ClassStr2.MyProcStr2 PROCEDURE(<STRING MyString>)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyString.
!***********************************
Постараемся оценить эти решения с точки зрения эффективности кода (скорости выполнения). Об эффективности стиля программирования в данном случае можно много и бесплодно спорить.
Тест во вложении, вот результаты, полученные на моей машине:
1. Строка. Перегрузка (423) , OMITTED(271)
2. Число. Перегрузка (6) , OMITTED(3)
Итак, для этой (на мой взгляд стандартной) задачи использование OMITTED более эффективно.
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Дуга Михаил <mikeduglas@intercare.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 9:42:51
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Владимир!
из вложения:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyLong.
!***********************************
тут long SELF.MyProp='DEFAULT', может на результат повлиять.
С уважением, Михаил
----- Original Message -----
From: Vladimir Yakimchenko
To:clalist List Member
Sent: Monday, October 18, 2004 9:30 AM
Subject: Re: Re[7]: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Привет, Всем!
From: Чушкин Сергей
Мы же вроде определились, что всё зависит от КОНКРЕТНЫХ условий.
В частности, наиболее заметный выигрыш в скорости от перегрузки
получается, если процедура работает только с внешними переменными,
что наиболее характерно для классов (свойства+методы).
Давайте же сформулируем КОНКРЕТНЫЕ условия и проведем наконец тест, чтоб определиться что же все таки эффективней. Итак, конкретные условия для задачи с опускаемым параметром и со значением по умолчанию, которая изначально (в общих чертах) обсуждалась с Николаем Цигуро.
Есть класс, у класса есть свойство, это свойство надо инициализировать. Инициализация осуществляется методом класса с параметром. При инициализации параметр может быть опущен, в этом случае используется значение по умолчанию. Все согласны с условиями? Теперь подумаем, кто как решил бы подобную задачу.
Предлагается два варианта (предположим строковый параметр)
1. через перегрузку методов
ClassStr1 CLASS
MyProp STRING(50)
MyProcStr1 PROCEDURE
MyProcStr1 PROCEDURE(STRING MyString)
END
!***********************************
ClassStr1.MyProcStr1 PROCEDURE
CODE
SELF.MyProcStr1('DEFAULT')
!***********************************
ClassStr1.MyProcStr1 PROCEDURE(STRING MyString)
CODE
SELF.MyProp = MyString
!***********************************
1. через OMITTED
ClassStr2 CLASS
MyProp STRING(50)
MyProcStr2 PROCEDURE(<STRING MyString>)
END
!***********************************
ClassStr2.MyProcStr2 PROCEDURE(<STRING MyString>)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyString.
!***********************************
Постараемся оценить эти решения с точки зрения эффективности кода (скорости выполнения). Об эффективности стиля программирования в данном случае можно много и бесплодно спорить.
Тест во вложении, вот результаты, полученные на моей машине:
1. Строка. Перегрузка (423) , OMITTED(271)
2. Число. Перегрузка (6) , OMITTED(3)
Итак, для этой (на мой взгляд стандартной) задачи использование OMITTED более эффективно.
Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Vladimir Yakimchenko <V.Yakimchenko@vaz.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 10:11:37
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Привет, Всем!
Пардон, сделал под копирку и ошибся. Правильно, конечно так:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
SELF.MyProp = MyLong
!***********************************
Но на результат это не повлияло (Перегрузка (6), OMITTED (3)), что лишний раз доказывает, что время выполнения if, по сравнению с конструкцией выполнения дополнительного метода, ничтожно
.Удачи!
__________________________________
Владимир Якимченко (IСQ 16 993 194)
----- Original Message -----
From: Дуга Михаил
To:clalist List Member
Sent: Monday, October 18, 2004 10:42 AM
Subject: Re: Re[7]: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Привет, Владимир!
из вложения:
!***********************************
ClassLong2.MyProcLong2 PROCEDURE(LONG MyLong = 10)
CODE
IF OMITTED(2) ; SELF.MyProp = 'DEFAULT'
ELSE ; SELF.MyProp = MyLong.
!***********************************
тут long SELF.MyProp='DEFAULT', может на результат повлиять.
С уважением, Михаил
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 1:43:27
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Vadim,
Sunday, October 17, 2004, 5:07:38 PM, you wrote:
VS> Hello Чушкин,
VS> Sunday, October 17, 2004, 3:58:42 AM, you wrote:
ЧС>> Здравствуйте
ЧС>> From: Vadim Sinyavskiy
ЧС>> Так что я слабо себе представляю реальную процедуру, где бы был смысл
ЧС>> заводить разговор про more efficient. А уже про much - так лучше бы
ЧС>> техписателям хелпа не позориться.
ЧС>> Если уж быть честными до конца, то и будем
ЧС>> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС>> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС>> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС>> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС>> с параметрами, переданными по значению.
ЧС>> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС>> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС>> Вот тебе и "much more efficient"
И чем здоровее параметр, тем более "much" получишь VS> Хорошо - будем честными.
VS> Рисуем тест:
VS> PROGRAM
VS> MAP
VS> Test1(<STRING Str>)
VS> Test2
VS> END
VS> LoopIndex LONG
VS> CODE
VS> Clock# = CLOCK()
VS> LOOP LoopIndex = 1 TO 10000000
VS> Test1()
VS> END
VS> T1# = CLOCK() - Clock#
VS> Clock# = CLOCK()
VS> LOOP LoopIndex = 1 TO 10000000
VS> Test2()
VS> END
VS> T2# = CLOCK() - Clock#
VS> STOP(T1# & ' *** ' & T2#)
VS> RETURN
VS> !-----------------------------------------------
VS> Test1 PROCEDURE(<STRING Str>)
VS> CODE
VS> RETURN
VS> !-----------------------------------------------
VS> Test2 PROCEDURE
VS> CODE
VS> RETURN
VS> !-----------------------------------------------
VS> Прогоняем - получаем фантастический выигрыш вызов второй процедуры -
VS> разница как минимум на порядок (а то и 14 раз)! Вот оно - "much more efficient"!!!
VS> Потому чухаем репку приходим к мысли - а не оторвались ли мы от народа
VS> с таким тестом? Народу нужны реалистичные тесты - и модифицируем тела
VS> обеих процедур:
VS> C LONG,AUTO
VS> A LONG,AUTO
VS> B LONG,AUTO
VS> CODE
VS> C = A + B
VS> получаем фантастическую по насыщенности кода процедуру и тестируем ее.
VS> Теперь запуск показывает, что теперь выигрышь составляет только раза 4.
VS> Идем дальше - декларируем коротенькую строку S STRING(20),AUTO и
VS> добавляем просто инициализацию S = '1234567890', балдеем от возрошего
VS> функционала тестовых процедур - но после запуска обнаруживаем, что
VS> выигрыш теперь сократился до 40 процентов.
VS> Какое отношение эти тесты имеют к реальным процедурам? Да никакого!
VS> Потому что:
VS> 1. В тесте нет никакого функционала - процедуры _абсолютно_ голые.
VS> 2. В тесте каждая их них вызывается 10 миллионов раз - только при
VS> таком числе повторе можно обсуждать разницу "голого" вызова.
Наверное тесты еще зависят от машин. Здесь старый Celeron633 и 128Мб
под w2k
test1/test2 =
419****16 =26.185 !на вашей 14
423****26 =16.269 !-"= 4
692****274 = 2.526 !-"= 0,4
Если посмотреть диспетчером задач на загрузку процессора, то при
вызове test1 время ядра подпрыгивает от 30 в 1-м случае до 10 в 3-м.
test2 вообще не вызывает изменение этого параметра.
Что же, мораль все же есть. Если придется использовать процедуры с
"голым функционалом" по 10 млн раз - буду знать что предпочтительнее.
А вообще-то "зацепились" в последний раз за то, что быстрее вызывается,
а не за внутреннюю функциональность. Если увеличить количество
параметров скажем до 6, то разрыв будет еще больше.
по третьему"функционалу": 2736 ***1677 = 1,63
При этом test2 вызывался _6_ раз, что по жизни не всегда бывает.
Или MyOpen(File) Или MyOpen(File,PassWord)
Да и содержание при полной функциональности в случае с передаваемыми
параметрами, мне кажется, в большинстве случаев будет более
насыщенным. Программист часто старается построить что-то
универсальное( "два в одном" и более). Машина будет бегать по ветвям
этой многофункциональной процедуры поболее, чем при прямом вызове
коротких перегружаемых процедур. И читать мне текст последних
легче.Когда-то читал, что если текст процедуры занимает более 2-х
экранов, то это плохо написанная программа. Только не помню кто. То ли
паскалев папа, то ли из старых книг по С. А тогда экран был.. Ну,
вобщем помните...
--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Олег А. Руденко <Oleg_Rudenko@mail.ru>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 16:13:40
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {02}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте, Чушкин!
воскресенье, 17 октября 2004 г., Вы писали:
ЧС> Если уж быть честными до конца, то и будем
ЧС> К скорости выполнения кода ВНУТРИ процедуры(метода) надо
ЧС> прибавить ещё скорость вызова самой процедуры. Так вот,
ЧС> вызов проц. без параметров заметно быстрее, чем вызов проц.
ЧС> с параметрами, передаваемыми по адресу, и ещё быстрее чем
ЧС> с параметрами, переданными по значению.
ЧС> Когда-то я тестировал это. Конкретных цифр не помню уже, но в
ЧС> памяти крепко засело, что хочешь скорости - пользуй без параметров.
ЧС> Вот тебе и "much more efficient"
И чем здоровее параметр, тем более "much" получишь Добавлю еще - первые omitted-параметры занимают регистры
для своих флажков. И остальные параметры передаются уже
через стек. А стек размещается в обычной памяти, которая
на порядок (на несколько?) медленнее процессорного регистра.
Это - не в упрек кому-либо!
Просто - если уж "... быть честными до конца ...",
то надо упомянуть обо всем.
=============================
С уважением, Олег А. Руденко.
Oleg_Rudenko@mail.ru
Oleg_Rudenko@mail333.com
Библиотека DynaLib
http://dynalib.narod.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Чушкин Сергей <chusha@mail333.com>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 17 октября 2004 г., 0:40:14
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: Сообщение.html
--====----====----====----====----====----====----====----====----====----===--
Здравствуйте
From: Владимир
[Кусь]
Как мне показалось, аргументы против перегрузки
звучали со стороны нелюбителей АВС.
[Кусь]
Меня тоже к ним причислил?
))[Кусь]
Основной вывод из этой дискуссии для меня следующий: большинство будет
складывать кубики так, как привыкли за предыдущие годы. Хотя правильно
все же выбирать инструмент применительно к ситуации. Я так думаю...
Правильно думаешь. Принципиальной разницы в способах нет, хотя теоретически
перегрузка методов работает быстрее. Но за всё нужно платить...
Мой опыт показывает что можно и нужно применять оба способа.
Обычно (обычно!) перегрузку применяю когда код сильно разнится в зависимости
от наличия или нет параметра. Или когда важны и проценты скорости выполнения.
Если объём кода приличный (десятки строк и более), а анализ параметра меняет
одну строку кода (или несколько), то использую пропуск. Обычно в этом коде
время на анализ пропущенного параметра составляет от сотых и менее долей
времени выполнения всего кода.
Например,
раньше я использовал метод ErrCode с пропуском параметра
i2Error.ErrCode procedure(<signed parErrorcode>)
сейчас использую с перегрузкой
i3Error.ErrCode procedure
i3Error.ErrCode procedure(signed parErrorcode)
т.к. этот метод используется везде, где только можно и уже стала важна скорость его вызова.
Другой случай - метод
i3RTL.Next procedure(*queue parQ, <signed parPointer>, signed parFlag=0)
здесь нет смысла делать перегрузку, т.к. код будет отличаться только одной строкой (из двух десятков)
if omitted(parPointer) then parPointer = pointer(parQ) end
плюс к тому же в этом методе оператор
get(parQ, parPointer)
на два порядка медленнее чем анализ пропуска параметра. Плюс вызов других методов, а
вызов любого метода (Процедуры) также медленнен как и GET.
p.s.
Я уже не помню с чего начали, но спор что "круче" в данном вопросе мне тоже не понятен :/
Сергей - chusha@mail333.com ; chusha@hotbox.ru
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
От: Владимир <ut5jbh@ua.fm>
Кому: "clalist List Member" <clalist@clarion.ru>
Написано: 18 октября 2004 г., 0:03:38
Тема: OMITted параметры можно отследить {02} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01} {01}
Файлы: <none>
--====----====----====----====----====----====----====----====----====----===--
Hello Чушкин,
Saturday, October 16, 2004, 11:40:14 PM, you wrote:
ЧС> Как мне показалось, аргументы против перегрузки
ЧС> звучали со стороны нелюбителей АВС.
ЧС> Меня тоже к ним причислил?
))ЧС> Сергей - chusha@mail333.com ; chusha@hotbox.ru
Да нет. Никого ни к кому не причислил. Я ж не совсем круглый ( далее
по выбору). Просто захотелось немножко подзавести народ. Как Тимур Вас
с тетками купил. (А я не полез: Чукча умный, чукча Тимура знает..) К
тому же я думаю, что это готовый кусок для будущего хелпа , если
вырезать некоторые личностные моменты. Вот Вадим даже тест-пример
сделал и не полез за своей дежурной базукой. Никто из третьей лиги не
сомневается в вашей квалификации, но как Вас заставить поделться
своими познаниями? Ведь еще 250 человек сидят за своими мониками и с
благодарностью внимают.
К тому ж когда еще грандам отмстишь за их бесконечные : "Все в RTFM!"
)--
Best regards,
Владимир mailto:ut5jbh@ua.fm
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Написал: ClaList(2)
