UDP тюнинг ubuntu - как?
Нет, вы не можете. Но если у вас есть исходный RPM, это означает, что у вас есть исходный код, поэтому вы можете упаковать его как DEB в любом случае, что является хорошей новостью!
Самый простой способ сделать быстрый пакет DEB - использовать checkinstall.
8 ответов
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
-
1Я использую boost поток для каждого клиента. Я открываю поток, который открывает сокеты TCP и UDP. Это не хорошо? – EiTkoCaT 11 September 2011 в 01:43
-
2Это зависит от деталей реализации. Например, если у вас есть поток для каждого клиента, это означает, что для выполнения небольшого количества работы для каждого из 100 клиентов требуется 100 переключателей контекста. Но, скорее всего, ваша проблема связана с обработкой, которую вы делаете между вызовами для отправки / получения дейтаграмм UDP. – David Schwartz 11 September 2011 в 04:22
-
3Итак, каково было бы решение? – EiTkoCaT 11 September 2011 в 19:46
-
4См. Обновление моего ответа. По сути, либо сделать ваш код использовать меньше процессор или сделать его использовать преимущества ядра более эффективно. – David Schwartz 12 September 2011 в 05:53
-
5Эй, хорошо, я сделал это. Но все же на игровом сервере с подключенными людьми у меня возникла проблема. Зачем? Что мне делать? – EiTkoCaT 16 September 2011 в 21:23
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема не связана с УДП напрямую. Проблема в том, что один из ваших ядер превышен и некоторые приложения, вовлеченных в Использование udp не может воспользоваться более чем одним ядром. Ваш выбор профиль/оптимизировать его, чтобы заставить его выполнять свою работу с имеющимися ресурсами или переработать его, чтобы использовать несколько потоков или несколько процессов, так что он может воспользоваться другими ядрами.
точно, как вы делаете это зависит от того, что не так с кодом. Возможно, если код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
в этом случае решением будет либо оптимизировать do_other_stuff или переместить его на другой поток.
другая возможность состоит в том, если код выглядит так:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
в этом случае, решение может иметь более одного потока делает работу, которая генерирует udp пакет или обработки пакетов udp.
в принципе, вы должны либо уменьшить количество ЦП для каждого udp пакета или вам нужно повысить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.
Ваша проблема напрямую связана с UDP. Проблема в том, что один из ваших ядер максимален, и какое-то приложение, участвующее в вашем использовании UDP, не может использовать преимущества более чем одного ядра. Ваш выбор состоит в том, чтобы профилировать / оптимизировать его, чтобы заставить его выполнять свою работу с доступными ресурсами или переделать его для использования нескольких потоков или нескольких процессов, чтобы он мог использовать преимущества других ядер.
Точно так же вы делаете это, это зависит от того, что не так с кодом сейчас. Одна из возможностей заключается в том, что код выглядит примерно так:
while(1)
{
do_udp_stuff(); // this is fairly simple
do_other_stuff(); // this is complex
}
В этом случае решение должно либо оптимизировать do_other_stuff, либо переместить его в другой поток.
Другая возможность заключается в том, что код выглядит следующим образом:
while(1)
{
do_some_work_which_generates_a_UDP_Packet();
send_udp_patch();
}
// or
while(1)
{
receive_UDP_packet();
process_UDP_packet();
}
В этом случае решение может состоять в том, чтобы иметь более одного потока, выполняющего работу, которая генерирует UDP-пакет или обрабатывает пакет UDP.
В принципе, вам нужно либо уменьшить количество CPU, которое вы используете на UDP-пакет, либо увеличить эффективность использования процессора, распределив работу над ядрами.