Есть ли разница в быстродействии если я унаследуюсь от интерфейса или базового типа
Например можно обьявить интерфейс с функцией
а можно сделать базовый класс с такой же функцией.
Вопрос — будет ли разница в быстродействии при обращении к этим методам.
Просто предпологается что обращений будут миллионы — и хочется заранее выбрать правильную стратегию.
Не задумывайтесь об этом, делайте так, как удобнее — если базовый класс должен определять какие-то методы и свойства с реализацией по уолчанию, то, разумеется, используте класс, если же нет, то интерфейс.
Здравствуйте, Alexander_fx, Вы писали:
A_>Есть ли разница в быстродействии если я унаследуюсь от интерфейса или базового типа A_>Например можно обьявить интерфейс с функцией A_>а можно сделать базовый класс с такой же функцией. A_>Вопрос — будет ли разница в быстродействии при обращении к этим методам. A_>Просто предпологается что обращений будут миллионы — и хочется заранее выбрать правильную стратегию.
Виртуальная функция быстрее (раза в 3), но заметить это можно только если ее вызывать в огромных циклах и при этом тело метода будет содержаь нечто вроде операций сложения или умножения. Так что в 99% случаев разница будет даже в микроскоп не видна.
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Здравствуйте, VladD2, Вы писали:
VD>Здравствуйте, Alexander_fx, Вы писали:
A_>>Есть ли разница в быстродействии если я унаследуюсь от интерфейса или базового типа A_>>Например можно обьявить интерфейс с функцией A_>>а можно сделать базовый класс с такой же функцией. A_>>Вопрос — будет ли разница в быстродействии при обращении к этим методам. A_>>Просто предпологается что обращений будут миллионы — и хочется заранее выбрать правильную стратегию.
VD>Виртуальная функция быстрее (раза в 3), но заметить это можно только если ее вызывать в огромных циклах и при этом тело метода будет содержаь нечто вроде операций сложения или умножения. Так что в 99% случаев разница будет даже в микроскоп не видна.
Так же пишу — вызываться будут миллионы — если не миллиарды раз.
У меня програ считает по несколько дней.
Только я пока не образованный.
Виртуальная функция это интерфейс или наследование от базового класса????
Здравствуйте, Lloyd, Вы писали:
L>Здравствуйте, Alexander_fx, Вы писали:
A_>>Только я пока не образованный. A_>>Виртуальная функция это интерфейс или наследование от базового класса????
L>Виртуальная — это способ вызова.
Ребята — простите — но есть ли в VBNET эта виртуальность — и как она реализуется.
А то что то хелп с первого раза ничего не дал.
Здравствуйте, Alexander_fx, Вы писали:
A_>Ребята — простите — но есть ли в VBNET эта виртуальность — и как она реализуется. A_>А то что то хелп с первого раза ничего не дал.
Public Overridable Function ToString() As String
Public Overrides Function ToString() As String
Здравствуйте, Lloyd, Вы писали:
L>Здравствуйте, Alexander_fx, Вы писали:
A_>>Ребята — простите — но есть ли в VBNET эта виртуальность — и как она реализуется. A_>>А то что то хелп с первого раза ничего не дал.
L>
L>Public Overridable Function ToString() As String
L>Public Overrides Function ToString() As String
L>
Ok — с этими фичами знаком — только не знал что это так называется.
Спасибо.
Re: Есть ли разница в быстродействии???
От:
Аноним
Дата:
10.10.06 14:35
Оценка:
Здравствуйте, gaidar, Вы писали:
G>Не задумывайтесь об этом, делайте так, как удобнее
С этой философией собственно .NET и разрабатывался
Здравствуйте, Alexander_fx, Вы писали:
A_>Так же пишу — вызываться будут миллионы — если не миллиарды раз. A_>У меня програ считает по несколько дней.
Тогда однозначно виртуальная функция. А еще лучше обойтись обычной фукнцией. Ее заинлайнят и будет еще раза в 3-4 быстрее.
Только еще раз подчеркну, что разницу ты увидишь, если функция примитивна (1-3 простых команды). Если там цикл, то можно начхать на то что это за реализация.
A_>Только я пока не образованный. A_>Виртуальная функция это интерфейс или наследование от базового класса????
Наследование от базовго класса. Реализация функции интерфейса она и есть реализация.
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Здравствуйте, <Аноним>, Вы писали:
G>>Не задумывайтесь об этом, делайте так, как удобнее
А>С этой философией собственно .NET и разрабатывался
С этой философией жувут те ктого не принято называть маняками битодробителями. И это верно, так как случаев оптимизации по делу в тысячи раз меньше чем случаев когда оптимизации не по делу усложняли решения и даже губили проекты.
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Здравствуйте, Alexander_fx, Вы писали:
A_>Есть ли разница в быстродействии если я унаследуюсь от интерфейса или базового типа A_>Например можно обьявить интерфейс с функцией A_>а можно сделать базовый класс с такой же функцией. A_>Вопрос — будет ли разница в быстродействии при обращении к этим методам. A_>Просто предпологается что обращений будут миллионы — и хочется заранее выбрать правильную стратегию.
Можно провести такой эксперимент:
namespace Calls
{
class Base
{
public virtual void Foo()
{
}
}
class Derived : Base
{
public override void Foo()
{
}
}
interface IBase
{
void Bar();
}
class Realizer : IBase
{
public void Bar()
{
}
}
class Program
{
static void Main(string[] args)
{
Base b = new Derived();
IBase ib = new Realizer();
b.Foo();
ib.Bar();
}
}
}
Вдогонку:
Я проводил эксперименты по измерению времени виртуального вызова.
На Pentium4 Prescott он выполняется за 15 машинных тактов. Для сравнения команда деления выполняется за 40 тактов, вычисление синуса за 270 тактов. То есть за время одного деления можно выполнить почти 2.5 виртуальных вызова.
Если например в твоей программе выполняется 1,000,000 виртуальных вызовов в секунду, то это примерно 15,000,000 машинных тактов. При тактовой частоте 3 ГГц это будет 15 / 3000 * 100% = 0.5%. То есть при 1,000,000 вызовов в секунду мы тратим всего пол процента машинного времени.
Много это или мало — решать тебе.
Здравствуйте, Alexander_fx, Вы писали:
A_>Есть ли разница в быстродействии если я унаследуюсь от интерфейса или базового типа A_>Например можно обьявить интерфейс с функцией A_>а можно сделать базовый класс с такой же функцией. A_>Вопрос — будет ли разница в быстродействии при обращении к этим методам. A_>Просто предпологается что обращений будут миллионы — и хочется заранее выбрать правильную стратегию.
В MSDN есть табличка со списком того, сколько стоит тот или иной вызов. Статья называется Writing Faster Managed Code: Know What Things Cost
В целом текущая ситуация такова, что на вызов метода через интерфес нужно на пару инструкций больше чем, это нужно для виртуального вызова. Но, круче всего это виртуальные generic методы. для их вызова накладные расходы самые большие.
Соотношение может быть примерно следующим
вирт. метод: 1.0
интерфейсный метод: 1.1
generic вирт. метод: 7.0
Но, как уже говорили, надо смотреть на сам метод. Скорее всего, самым медленным будет именно его тело, а накладные расходы на вызов метода пару миллионов раз будут не видны даже в микроскоп...
Если у Вас нет паранойи, то это еще не значит, что они за Вами не следят.
Есть ли разница в быстродействии???
От:
Аноним
Дата:
11.10.06 02:36
Оценка:
Производительность вызова кода в порядке убывания.
1. Метод в том же классе.
2. Метод в базовом классе.
3. Абстрактный метод.
4. Метод интерфейса.
Интерфейсы и генерики самое тормознутое из ООП, по возможности нужно не использовать их.
Здравствуйте, VladD2, Вы писали:
VD>С этой философией жувут те ктого не принято называть маняками битодробителями. И это верно, так как случаев оптимизации по делу в тысячи раз меньше чем случаев когда оптимизации не по делу усложняли решения и даже губили проекты.
Да, преждевременная оптимизация — зло.
Re: Есть ли разница в быстродействии???
От:
Аноним
Дата:
12.10.06 00:33
Оценка:
Dufrenite
Если например в твоей программе выполняется 1,000,000 виртуальных вызовов в секунду, то это примерно 15,000,000 машинных тактов. При тактовой частоте 3 ГГц это будет 15 / 3000 * 100% = 0.5%. То есть при 1,000,000 вызовов в секунду мы тратим всего пол процента машинного времени.
Много это или мало — решать тебе.
Ты не учел только одного, что команды на конвеер подаются со скоростью системной шины, много это или мало решать тебе
TK>Соотношение может быть примерно следующим TK>вирт. метод: 1.0 TK>интерфейсный метод: 1.1 TK>generic вирт. метод: 7.0
А можно ссылку на источник с данными про вызовы в generic?
В приведенной статье нет информации про Generic, а мне кажется, что коэффициенты 1.0 и 7.0 не соответствуют действительности. Не знаю как это реализовали в Microsoft, но вызов в Generic по логике не должен отличаться от интерфейсного метода, так как в C# generic точно знает VTable от объектов, к которым обращается. К тому, что Generic не знает, он и обратиться не даст (в отличие от С++ )
Hello, "eugen1001" > > TK>Соотношение может быть примерно следующим > TK>вирт. метод: 1.0 > TK>интерфейсный метод: 1.1 > TK>generic вирт. метод: 7.0 > > А можно ссылку на источник с данными про вызовы в generic? > > В приведенной статье нет информации про Generic, а мне кажется, что > коэффициенты 1.0 и 7.0 не соответствуют действительности.
Можно написать простейший тест и, посмотреть самому...
Posted via RSDN NNTP Server 2.0
Если у Вас нет паранойи, то это еще не значит, что они за Вами не следят.
Есть ли разница в быстродействии???
От:
Аноним
Дата:
12.10.06 05:39
Оценка:
>>Интерфейсы и генерики самое тормознутое из ООП, по возможности нужно не использовать их.
Здравствуйте, TK, Вы писали:
TK>Можно написать простейший тест и, посмотреть самому...
Тест написал. По его результатам коэффициенты немного различаются от заявленны (FW 2.0):
Метод класса: 8589935155
Виртуальный метод класса: 8589935154
Шаблонный метод класса: 8589935155
Шаблонный виртуальный метод к: 68719480845
Метод интерфейса: 12884902529
Метод шаблона: 8589935154
Виртуальный метод шаблона: 8589935139
Шаблонный метод шаблона: 8589935170
Виртуальный шаблонный метод ш: 68719480846
Метод интерфейса шаблона: 12884902513
Метод с параметром generic-ин: 8589935232
Шаблонный метод generic-интер: 68719480846
Также я проанализировал assembler для случая "Шаблонный виртуальный метод к":
00000067 push 0A29BD0h
0000006c mov ecx,edi
0000006e mov edx,0A299E8h
00000073 call 791949BF // этот вызов похоже и вычисляет адрес функции вызова, и делает это не быстро.
00000078 mov esi,eax
0000007a mov ecx,edi
0000007c call esi
И вот код теста:
namespace TestCallMethods
{
public class TestBase
{
public const int Times = 100000000;
[System.Runtime.InteropServices.DllImport("KERNEL32")]
public static extern bool QueryPerformanceCounter(
ref long lpPerformanceCount);
[System.Runtime.InteropServices.DllImport("KERNEL32")]
public static extern bool QueryPerformanceFrequency(
ref long lpFrequency);
[System.Runtime.InteropServices.DllImport("KERNEL32")]
public static extern UInt64 GetTickCount();
}
public class Program
{
static void Main(string[] args)
{
Console.ReadLine();
TestNoneTemplate.Test();
TestTemplate.Test();
Console.ReadLine();
}
}
public interface IBase
{
void Foo();
}
public class Base : IBase
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void Foo()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public void FooS()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void FooT<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public void FooTS<T>()
{
}
}
public class Derived : Base
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void Foo()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void FooT<T>()
{
}
}
public class TestNoneTemplate
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public static void Test()
{
TestBS();
TestBV();
TestBTS();
TestBT();
TestIB();
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBS()
{
Console.Write("Метод класса: ");
UInt64 oldTick = TestBase.GetTickCount();
Base bs = new Base();
for (int i = 0; i < TestBase.Times; i++)
{
bs.FooS();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBV()
{
Console.Write("Виртуальный метод класса: ");
UInt64 oldTick = TestBase.GetTickCount();
Base bv = new Derived();
for (int i = 0; i < TestBase.Times; i++)
{
bv.Foo();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBTS()
{
Console.Write("Шаблонный метод класса: ");
UInt64 oldTick = TestBase.GetTickCount();
Base bts = new Derived();
for (int i = 0; i < TestBase.Times; i++)
{
bts.FooTS<int>();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBT()
{
Console.Write("Шаблонный виртуальный метод к: ");
UInt64 oldTick = TestBase.GetTickCount();
Base bt = new Derived();
for (int i = 0; i < TestBase.Times; i++)
{
bt.FooT<int>();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestIB()
{
Console.Write("Метод интефейса: ");
UInt64 oldTick = TestBase.GetTickCount();
IBase ib = new Derived();
for (int i = 0; i < TestBase.Times; i++)
{
ib.Foo();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
}
public interface IBaseT<T>
{
void Foo<T>();
void Foo(T t);
}
public class BaseT<T> : IBaseT<T>, IBase
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void Foo()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public void FooS()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void FooT<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public void FooTS<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void Foo<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public virtual void Foo(T t)
{
}
}
public class DerivedT<T> : BaseT<T>
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void Foo()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void FooT<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void Foo<T>()
{
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public override void Foo(T t)
{
}
}
public class TestTemplate
{
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
public static void Test()
{
TestBS();
TestBV();
TestBTS();
TestBVTS();
TestIB();
TestIBTP();
TestITBTP();
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBS()
{
Console.Write("Метод шаблона: ");
UInt64 oldTick = TestBase.GetTickCount();
BaseT<int> bs = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
bs.FooS();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBV()
{
Console.Write("Виртуальный метод шаблона: ");
UInt64 oldTick = TestBase.GetTickCount();
BaseT<int> b = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
b.Foo();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBTS()
{
Console.Write("Шаблонный метод шаблона: ");
UInt64 oldTick = TestBase.GetTickCount();
BaseT<int> bts = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
bts.FooTS<int>();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestBVTS()
{
Console.Write("Виртуальный шаблонный метод ш: ");
UInt64 oldTick = TestBase.GetTickCount();
BaseT<int> bt = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
bt.FooT<int>();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestIB()
{
Console.Write("Метод интерфейса шаблона: ");
UInt64 oldTick = TestBase.GetTickCount();
IBase ib = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
ib.Foo();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestIBTP()
{
Console.Write("Метод с параметром generic-ин: ");
UInt64 oldTick = TestBase.GetTickCount();
IBaseT<int> ibt = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
ibt.Foo(0);
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.NoInlining)]
private static void TestITBTP()
{
Console.Write("Шаблонный метод generic-интер: ");
UInt64 oldTick = TestBase.GetTickCount();
IBaseT<int> tibt = new DerivedT<int>();
for (int i = 0; i < TestBase.Times; i++)
{
tibt.Foo<int>();
}
UInt64 dTick = TestBase.GetTickCount() - oldTick;
Console.WriteLine(dTick.ToString().PadLeft(12));
}
}
}
Здравствуйте, eugen1001, Вы писали:
TK>>Можно написать простейший тест и, посмотреть самому...
E>Тест написал. По его результатам коэффициенты немного различаются от заявленны (FW 2.0):
E>
E>Виртуальный метод класса: 8589935154
E>Шаблонный виртуальный метод к: 68719480845
E>
Ну, я же и не говорил, что на мои коэффициэнты молиться надо Между тем, разница в 8 раз все равно показательна.
PS
Почему бы не использовать готовый класс из framework — System.Diagnostics.Stopwatch?
Если у Вас нет паранойи, то это еще не значит, что они за Вами не следят.
Здравствуйте, TK, Вы писали:
TK>Ну, я же и не говорил, что на мои коэффициэнты молиться надо Между тем, разница в 8 раз все равно показательна.
Меня больше поразило, что вызов простого и виртуального метода совпали
Надо переделать тест .
TK>PS TK>Почему бы не использовать готовый класс из framework — System.Diagnostics.Stopwatch?
Ну это по не знанию Спасибо за науку.
Код по замеры просто взял из чужого примера
Здравствуйте, Nimnul, Вы писали:
N>Ты не учел только одного, что команды на конвеер подаются со скоростью системной шины, много это или мало решать тебе
)
Между тем, разница в 8 раз все равно показательна. 