SQL-сервер параллельный доступ
Когда SQL-сервер получает два запроса (ВЫБОР * От the_Same_Table) в точно то же время, и если у Вас есть сервер с несколькими процессорами, SQL-сервер может получить данные одновременно?
Я пытаюсь понять то, что произойдет, если дешевый избранный оператор, которые заканчиваются в течение.01 секунд и 1 000 пользователей, выполнит тот же запрос точно одновременно. Я думаю, что произойдет что, если сервер будет иметь четыре процессора, то SQL-сервер будет служить первым четырем за.01 секунд и служить следующим четырем пользователям за 0,02 секунды, дополнительные.
Это даже близко к тому, что на самом деле произойдет?
Я думаю, что попытаюсь использовать некоторый код и регистраторы для тестирования этого, или возможно существуют надежные инструменты тестирования, чтобы сделать это.
Спасибо
3 ответа
Нет, ваше предположение о последовательной обработке неверно, эта тема становится очень сложной и глубокой - пытаясь сделать то, что я знаю об этом просто:
Каждому запросу назначен поток, и планировщик использует совместное планирование, а не упреждающее, так что каждый поток может отказаться от выделения (кванты) времени, прежде чем он будет принудительно обработан планировщиком. Каждый запрос должен будет делать запросы на данные из буферного пула, что может означать ожидание в IO/сети и т.д., так что они будут поражать состояния ожидания и выдавать свои кванты времени обработки.
Если процесс больше не ожидает ресурс, он может повторно ввести список потоков, доступных для обработки, и затем получить еще один квант времени для обработки запроса.
В действительности запросы выполняются параллельно, но детерминированно предсказать порядок завершения запросов невозможно.
Чтобы углубиться в это, я думаю, что книга SQL 2008 Internals от Калена Дилейни (Adam Mechanic, Kimberley Tripp, Paul Randal) является хорошей отправной точкой, или старая книга SQL Server 2000 Architecture Кена Хендерсона, которая также была очень низкой.
Я должен был бы вернуться к курсовым записям, чтобы вспомнить точный процесс - он доходит до вопроса - «поскольку вы не можете повлиять на это напрямую, почему вы спрашиваете?»
-121--3802393-Концептуально, это нормально - вы не идете против духа «безбивного агрегата». Проблема в том, что структура больше не является типом POD, поэтому стандарт делает меньше гарантий о его поведении и он не может храниться в союзе.
Вы рассматривали это вместо этого?
Position p = {12.34, 56.78};
Каждый пакет (запрос), поступающий в SQL Server, создает задачу. Задачи планируются к выполнению и подбираются работником. Рабочий очень похож на поток. Задача остается с работником до его завершения, а затем освобождает его, чтобы забрать другую задачу. В системе имеется ограниченное число работников, настроенных sp _ configure 'max worker threads' . Как минимум насчитывается 256 работников, из которых около 35 являются системными. Работнику необходим планировщик для запуска, и для каждого ядра ЦП существует один планировщик. Работники сотрудничают в совместном использовании планировщика.
Некоторые задачи порождают подзадачи, например параллельные запросы. Эти задачи также ставятся в очередь для выполнения и должны быть выполнены работником. Задачи, порождающие подзадачи, не могут быть выполнены до тех пор, пока не будут выполнены все задачи, которые они порождают.
Существуют также некоторые системные задачи, управляемые действиями пользователя, такие как квитирование входа в систему. Когда клиент открывает новое соединение, квитирование и аутентификация/авторизация входа выполняются задачей, для которой требуется работник.
Когда 1000 запросов поступают на сервер, 1000 задач создаются и ставятся в очередь для выполнения. Свободные работники подбирают задания и начинают их выполнять. По завершении одной задачи они забирают следующую задачу до тех пор, пока все задачи, созданные 1000 запросами, не завершатся.
DMV, которые показывают, что происходит:
These подробности описаны в разделе Планирование пакетов или задач SQL Server и в блоге Славы .
После выполнения задачи запрос будет скомпилирован. При компиляции сначала выполняется поиск текста запросов в памяти и поиск существующего скомпилированного плана для запроса с идентичным планом. Вы можете прочитать мой ответ на Динамически созданные параметры SQL vs в SQL Server , чтобы более подробно разобраться в том, как это происходит. См. также Кэширование и повторное использование плана выполнения . После создания плана он запускается в исполнение. Запрос типа SELECT... Таблица FROM создаст тривиальный план, в котором имеется всего пара операторов, которые в основном извлекают каждую строку и помещают ее в поток TDS обратно клиенту. План запроса - это дерево операторов, и запрос всегда выполняется путем запроса корня дерева для следующей строки в цикле, пока корень не вернет EOF. Операторы запроса в дереве становятся все более специфичными, пока нижний оператор не будет физическим доступом к выбранному пути доступа (индекс или куча, выбранная оптимизатором для удовлетворения запроса). См. раздел Обработка инструкций SQL . Доступ к индексу всегда запрашивает данные из буферного пула, но не с диска. Если в буферном пуле запрошенная страница не кэширована, на странице помещается PAGEIOLATCH и в подсистему ввода-вывода отправляется запрос на чтение страницы. Последующие запросы для той же страницы будут ждать завершения этого ввода-вывода, и как только страница окажется в буферном пуле, все другие запросы, которые нуждаются в этой странице, будут поступать из буферного пула. неиспользуемые страницы удаляются, когда буферный пул нуждается в свободных страницах, но если система имеет достаточно оперативной памяти, страница никогда не будет удалена после загрузки. Операции индексирования и сканирования кучи будут запрашивать данные чтения, ожидая, что будут запрошены страницы, предшествующие текущей в цепочке ссылок на страницы. Считывание заголовков ограничено фрагментами index contiguos, и это происходит, когда фрагментация индекса попадает в картину, поскольку уменьшает размер запросов на чтение вперед, см. Общие сведения о страницах и экстентах .
Другим аспектом выполнения запроса является логическая блокировка строк. Для обеспечения стабильности при чтении могут устанавливаться блокировки строк или диапазонов, в зависимости от модели изоляции, на считываемых строках, чтобы предотвратить совпадающие обновления во время сканирования запроса. На уровне изоляции SNAPSHOT запрос вообще не будет запрашивать блокировки, но вместо этого будет использоваться метка версии для возможной обработки данных, запрошенных из хранилища версий (см. SQL Server 2005 Server Versioning-Based Transaction Isolation ). При изоляции READ UNCOMMITED (или при использовании подсказки nolock) запрос не запрашивает блокировок для строк, которые он читает, но при совпадающих обновлениях чтения являются несогласованными (считываются незафиксированные строки, одна и та же строка может быть прочитана дважды или существующая строка может не быть прочитана вовсе).
Может ли помочь структура визуализации штрихкодов в Codeplex GitHub?
Обратите внимание, что без конструктора следующее уже делает то, что вам нужно:
int main()
{
Position pos = { 12.34, 56.78 };
travelTo(pos);
Position pos2 = {}; // zero initialises
travelTo(pos2);
}
Нет, ваше предположение о последовательной обработке неверно, эта тема становится очень сложной и глубокой - пытается сделать то, что я знаю об этом просто:
Каждый запрос имеет назначенный поток, и планировщик использует совместное планирование, а не упреждающее, так что каждый поток может отказаться от выделения (кванты) времени, прежде чем он будет принудительно обработан планировщиком. Каждый запрос должен будет делать запросы на данные из буферного пула, что может означать ожидание в IO/сети и т.д., так что они будут поражать состояния ожидания и выдавать свои кванты времени обработки.
Если процесс больше не ожидает ресурс, он может повторно ввести список потоков, доступных для обработки, и затем получить еще один квант времени для обработки запроса.
В действительности запросы выполняются параллельно, но детерминированно предсказать порядок завершения запросов невозможно.
Чтобы углубиться в это, я думаю, что книга SQL 2008 Internals от Калена Дилейни (Adam Mechanic, Kimberley Tripp, Paul Randal) является хорошей отправной точкой, или старая книга SQL Server 2000 Architecture Кена Хендерсона, которая также была очень низкой.
Я должен был бы вернуться к курсовым записям, чтобы вспомнить точный процесс - он доходит до вопроса - «поскольку вы не можете повлиять на это напрямую, почему вы спрашиваете?»
Попробуйте декомпилировать байтовый код и посмотрите, как отличается код. Я бы предположил, что компиляция разрешит их почти одинаково, и любая небольшая разница приведет к ничтожной разнице в производительности.
-121--2364675- Определите 'NEED', технически все, что вам нужно, это это : 
(источник: geeks3d.com )
SQL Server оптимизирован для выполнения одновременных нескольких операций чтения. Единственный раз, когда вы можете столкнуться с взаимоблокировкой, это если у вас много операций обновления происходит в той же таблице, к которой вы пытаетесь получить доступ. Однако в этом случае можно использовать nolock или даже установить уровень изоляции транзакции на READ UNCOMMITTED .
Теперь в отношении вашего вопроса многопоточности. В SQL Server используется что-то, называемое волокнами, которые похожи на подпоток. Таким образом, вы не обязательно увидите то же масштабирование потока процессора, которое вы ожидаете увидеть в многопроцессорной среде. Хотя SQL Server имеет доступ к определенному числу потоков, существует максимальное количество волокон, которые также могут использоваться. Вот почему вы можете иметь 1000 клиентов, имеющих доступ к одному и тому же серверу одновременно даже на небольших коробках.
Если вы действительно хотите попасть в планирование потоков/оптоволокна, вам нужно будет найти хорошего гаек и болтов SQL Server, который действительно получает это, как это сложно.
Просто поймите, что sql server оптимизирован для этого, и вам не нужно объединять его тестирование каким-либо образом, так как это уже было доказано с помощью инструментов, которые вы, вероятно, не сможете воссоздать.