О появлении поддержки cuda в wsl 2 / блог компании ruvds.com / хабр

Оглавление

Видеокарта и типы памяти

Регистровая память (register) является самой быстрой из всех видов. Определить количество регистров доступных GPU можно с помощью уже хорошо известной функции cudaGetDeviceProperties. Рассчитать количество регистров, доступных одной нити GPU, так же не составляет труда, для этого необходимо разделить общее число регистров на произведение количества нитей в блоке и количества блоков в гриде. Все регистры GPU 32 разрядные. В CUDA нет явных способов использования регистровой памяти, всю работу по размещению данных в регистрах берет на себя компилятор.
Локальная память (local memory) может быть использована компилятором при большом количестве локальных переменных в какой-либо функции. По скоростным характеристикам локальная память значительно медленнее, чем регистровая. В документации от nVidia рекомендуется использовать локальную память только в самых необходимых случаях. Явных средств, позволяющих блокировать использование локальной памяти, не предусмотрено, поэтому при падении производительности стоит тщательно проанализировать код и исключить лишние локальные переменные.
Глобальная память (global memory) – самый медленный тип памяти, из доступных GPU. Глобальные переменные можно выделить с помощью спецификатора __global__, а так же динамически, с помощью функций из семейства cudMallocXXX. Глобальная память в основном служит для хранения больших объемов данных, поступивших на device с host’а, данное перемещение осуществляется с использованием функций cudaMemcpyXXX. В алгоритмах, требующих высокой производительности, количество операций с глобальной памятью необходимо свести к минимуму.
Разделяемая память (shared memory) относиться к быстрому типу памяти. Разделяемую память рекомендуется использовать для минимизации обращение к глобальной памяти, а так же для хранения локальных переменных функций. Адресация разделяемой памяти между нитями потока одинакова в пределах одного блока, что может быть использовано для обмена данными между потоками в пределах одного блока. Для размещения данных в разделяемой памяти используется спецификатор __shared__.
Константная память (constant memory) является достаточно быстрой из доступных GPU. Отличительной особенностью константной памяти является возможность записи данных с хоста, но при этом в пределах GPU возможно лишь чтение из этой памяти, что и обуславливает её название. Для размещения данных в константной памяти предусмотрен спецификатор __constant__. Если необходимо использовать массив в константной памяти, то его размер необходимо указать заранее, так как динамическое выделение в отличие от глобальной памяти в константной не поддерживается. Для записи с хоста в константную память используется функция cudaMemcpyToSymbol, и для копирования с device’а на хост cudaMemcpyFromSymbol, как видно этот подход несколько отличается от подхода при работе с глобальной памятью.
Текстурная память (texture memory), как и следует из названия, предназначена главным образом для работы с текстурами. Текстурная память имеет специфические особенности в адресации, чтении и записи данных. Более подробно о текстурной памяти я расскажу при рассмотрении вопросов обработки изображений на GPU.

Example programs

More detailed documentation / feature walk-through is forthcoming. For now I’m providing two kinds of short example programs; browsing their source you’ll know essentially all there is to know about the API wrappers.

To build and run the examples (just as a sanity check), execute the following:

Modified CUDA samples

The CUDA distribution contains sample programs demostrating various features and concepts. A few of these — which are not focused on device-side work — have been adapted to use the API wrappers — completely foregoing direct use of the CUDA Runtime API itself. You will find them in the modified CUDA samples example programs folder.

CUDA и язык C:

Спецификаторы функций, которые показывают, как и откуда буду выполняться функции.
Спецификаторы переменных, которые служат для указания типа используемой памяти GPU.
Спецификаторы запуска ядра GPU.
Встроенные переменные для идентификации нитей, блоков и др. параметров при исполнении кода в ядре GPU .
Дополнительные типы переменных.

__host__ — выполнятся на CPU, вызывается с CPU (в принципе его можно и не указывать).
__global__ — выполняется на GPU, вызывается с CPU.
__device__ — выполняется на GPU, вызывается с GPU.

gridSize – размерность сетки блоков (dim3), выделенную для расчетов,
blockSize – размер блока (dim3), выделенного для расчетов,
sharedMemSize – размер дополнительной памяти, выделяемой при запуске ядра,
cudaStream – переменная cudaStream_t, задающая поток, в котором будет произведен вызов.

gridDim – размерность грида, имеет тип dim3. Позволяет узнать размер гридa, выделенного при текущем вызове ядра.
blockDim – размерность блока, так же имеет тип dim3. Позволяет узнать размер блока, выделенного при текущем вызове ядра.
blockIdx – индекс текущего блока в вычислении на GPU, имеет тип uint3.
threadIdx – индекс текущей нити в вычислении на GPU, имеет тип uint3.
warpSize – размер warp’а, имеет тип int (сам еще не пробовал использовать).

Настройка nvidia для cuda

Если драйвера установлены, мы приступаем к настройке.

Кликаем по рабочему столу правой кнопкой мыши, чтобы появилось всплывающее меню. В котором выбираем пункт: Панель управления NVIDIA

После этого мы попадаем в панель управления. Переходим в раздел: Параметры 3D

В появившемся окне сначала выбираем пункт: Регулировка настроек изображения с просмотром

Далее выбираем: Настройки согласно 3D-приложению

Переходим в раздел: Управление параметрами 3D

После этого приступаем к настройке параметров в правом окне.

Для корректной работы приложений необходимо выставить следующие параметры:

CUDA — графические процессоры: Все
Анизотропная фильтрация: Выключаем
V-Sync (вертикальная синхронизация): Выключаем
Вертикальный синхроимпульс: Использовать настройку 3D-приложения
Затенение фонового освещения: Выключаем
Максимальное количество заранее подготовленных кадров: следует выбрать пункт, который отмечен значком NVIDIA
Потоковая оптимизация: Автоматически
Режим управления электропитанием: Адаптивный
Сглаживание — гамма-коррекция: Выключаем
Сглаживание — параметры: Выключаем
Сглаживание — прозрачность: Выключаем
Сглаживание — режим: Выключаем
Тройная буферизация: Выключаем
Ускорение нескольких дисплеев/смешанных ГП: Режим многодисплейной производительности
Фильтрация текстур — анизотропная оптимизация по выборке: Выключаем
Фильтрация текстур — качество: Наивысшая производительность
Фильтрация текстур — отрицательное отклонение УД: Включаем
Фильтрация текстур — трилинейная оптимизация: Включаем
Анизотропная фильтрация. Прямым образом влияет на качество текстур в играх. Поэтому рекомендуется Выключить
Включить масштабируемые текстуры: Выключаем
Ограничение расширения: Выключаем

В зависимости от версии драйверов и видеокарты, некоторые параметры могут отсутвовать в настройках.После изменения всех настроек, нажимаем кнопку применить. Данные настройки не гарантируют 100% результата, но в 90% случаем они могут повысить FPS до 30%.

источник

Introduction

CUDA is a parallel computing platform and programming model developed by NVIDIA for general computing on graphical processing units (GPUs). With CUDA, developers are able to dramatically speed up computing applications by harnessing the power of GPUs.

In GPU-accelerated applications, the sequential part of the workload runs on the CPU – which is optimized for single-threaded performance – while the compute intensive portion of the application runs on thousands of GPU cores in parallel. When using CUDA, developers program in popular languages such as C, C++, Fortran, Python and MATLAB and express parallelism through extensions in the form of a few basic keywords.

Работа микропроцессора на примере вычисления факториала

Рассмотрим работу микропроцессора на конкретном примере выполнения им простой программы, которая вычисляет факториал от числа «5». Сначала решим эту задачку «в тетради»: факториал от 5 = 5! = 5 * 4 * 3 * 2 * 1 = 120

На языке программирования C этот фрагмент кода, выполняющего данное вычисление, будет выглядеть следующим образом:

a=1;f=1;while (a

Когда эта программа завершит свою работу, переменная f будет содержать значение факториала от пяти.

Компилятор C транслирует (то есть переводит) этот код в набор инструкций языка ассемблера. В рассматриваемом нами процессоре оперативная память начинается с адреса 128, а постоянная память (которая содержит язык ассемблера) начинается с адреса 0. Следовательно, на языке данного процессора эта программа будет выглядеть так:

// Предположим, что a по адресу 128// Предположим, что F по адресу 1290 CONB 1 // a=1;1 SAVEB 1282 CONB 1 // f=1;3 SAVEB 1294 LOADA 128 // if a > 5 the jump to 175 CONB 56 COM7 JG 178 LOADA 129 // f=f*a;9 LOADB 12810 MUL11 SAVEC 12912 LOADA 128 // a=a+1;13 CONB 114 ADD15 SAVEC 12816 JUMP 4 // loop back to if17 STOP

Теперь возникает следующий вопрос: а как же все эти команды выглядят в постоянной памяти? Каждая из этих инструкций должна быть представлена в виде двоичного числа. Чтобы упростить понимание материала, предположим, что каждая из команд языка ассемблера рассматриваемого нами процессора имеет уникальный номер:

LOADA — 1
LOADB — 2
CONB — 3
SAVEB — 4
SAVEC mem — 5
ADD — 6
SUB — 7
MUL — 8
DIV — 9
COM — 10
JUMP addr — 11
JEQ addr — 12
JNEQ addr — 13
JG addr — 14
JGE addr — 15
JL addr — 16
JLE addr — 17
STOP — 18

Будем считать эти порядковые номера кодами машинных команд (opcodes). Их еще называют кодами операций. При таком допущении, наша небольшая программа в постоянной памяти будет представлена в таком виде:

// Предположим, что a по адресу 128// Предположим, что F по адресу 129Addr машинная команда/значение0 3 // CONB 11 12 4 // SAVEB 1283 1284 3 // CONB 15 16 4 // SAVEB 1297 1298 1 // LOADA 1289 12810 3 // CONB 511 512 10 // COM13 14 // JG 1714 3115 1 // LOADA 12916 12917 2 // LOADB 12818 12819 8 // MUL20 5 // SAVEC 12921 12922 1 // LOADA 12823 12824 3 // CONB 125 126 6 // ADD27 5 // SAVEC 12828 12829 11 // JUMP 430 831 18 // STOP

Как вы заметили, семь строчек кода на языке C были преобразованы в 18 строчек на языке ассемблера. Они заняли в ПЗУ 32 байта.

Что такое CUDA

CUDA (англ. Compute Unified Device Architecture) — это технология на базе программно-аппаратной архитектуры, которая позволяет повысить производительность параллельных вычислений. Параллельные вычисления — это вычисления, при которых процесс разработки программного обеспечения делится на потоки. Потоки обрабатываются параллельно и взаимодействуют между собой в процессе обработки. Это возможно благодаря процессорам компании NVIDIA, на которых построена работа CUDA. В их основе лежит технология GPGPU.

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

Основные типы процессоров

CPU (англ. Central Processing Unit) — это центральный процессор, который ориентирован на обработку данных в максимально короткие сроки. Работает по следующему принципу: разбивает одну задачу на несколько потоков, каждый из которых обрабатывается отдельно. Затем эти потоки вновь объединяются и выстраиваются в нужном порядке. Такой подход позволяет увеличить скорость последовательной обработки задач. Подробнее читайте в статье Что такое процессор CPU.

GPU (англ. Graphics Processing Unit) — это специальный графический процессор, который заточен на обработку 2D или 3D-графики. Он размещается на видеокарте, что позволяет автоматически освободить основной процессор от лишней нагрузки при обработке данных. GPU состоит из нескольких тысяч ядер, которые в совокупности потребляют небольшое количество энергии. CUDA ядра «выигрывают» у CPU по производительности на 1 ватт потребляемой мощности.

На базе этих основных процессоров были разработаны различные специализированные инструменты. Например, технология GPGPU.

GPGPU (англ. General-purpose computing on graphics processing units) — это технология, которая позволяет использовать графический процессор GPU в операциях, которые обычно выполняет центральный процессор CPU. Например, в математических вычислениях. С помощью GPGPU можно использовать видеокарту для выполнения неграфических вычислений. При этом графический процессор будет работать не вместо центрального, а в качестве вычислительного блока.

CUDA является улучшенной вариацией GPGPU. Она позволяет работать на специальном диалекте — это значит, что программисты могут использовать алгоритмы, предназначенные для графических процессоров при обработке неспецифических задач. С помощью CUDA можно значимо ускорить процессы обработки. Например, можно сократить время ожидания конвертации видео до 20 раз, не задействуя основной процессор.

В каких областях можно использовать CUDA:

В последнее время технология высокоскоростной обработки становится ближе к рядовому пользователю. Например, уже существуют плагины для Photoshop, которые используют мощности GPU. С другими программами и проектами можно познакомиться на официальном сайте.

Key features

All functions and methods throw exceptions on failure — no need to check return values (the exceptions carry the status information).
Judicious namespacing (and some internal namespace-like classes) for better clarity and for semantically grouping related functionality together.
You can mostly forget about numeric IDs and handles; the proxy classes will fit everywhere.
Aims for clarity and straightforwardness in naming and semantics, so that you don’t need to look concepts up in the official documentation to understand what each class and function do.
Thin and lightweight:
- No work done behind your back, no caches or indices or any such thing.
- No costly inheritance structure, vtables, virtual methods and so on — vanishes almost entirely on compilation.
- Doesn’t really «hide» any of CUDA’s complexity or functionality; it only simplifies use of the Runtime API.

Vectors

Thrust provides two vector containers, host_vector and device_vector. As the names suggest, host_vector is stored in host memory while device_vector lives in GPU device memory. Thrust’s vector containers are just like std::vector in the C++ STL. Like std::vector, host_vector and device_vector are generic containers (able to store any data type) that can be resized dynamically. The following source code illustrates
the use of Thrust’s vector containers.

#include <thrust/host_vector.h>
#include <thrust/device_vector.h>

#include <iostream>

int main(void)
{
    
    thrust::host_vector<int> H(4);

    
    H = 14;
    H = 20;
    H = 38;
    H = 46;
    
    
    std::cout << "H has size " << H.size() << std::endl;

    
    for(int i = 0; i < H.size(); i++)
        std::cout << "H = " << H << std::endl;

    
    H.resize(2);
    
    std::cout << "H now has size " << H.size() << std::endl;

    
    thrust::device_vector<int> D = H;
    
    
    D = 99;
    D = 88;
    
    
    for(int i = 0; i < D.size(); i++)
        std::cout << "D = " << D << std::endl;

    
    return 0;
}

As this example shows, the = operator can be used to copy a host_vector to a device_vector (or vice-versa). The = operator can also be used to copy host_vector to host_vector or device_vector to device_vector. Also note that individual elements of a device_vector can be accessed using the standard bracket notation. However, because each of these accesses requires a call to cudaMemcpy, they should be used sparingly. We’ll look at some more efficient techniques later.

It’s often useful to initialize all the elements of a vector to a specific value, or to copy only a certain set of values
from one vector to another. Thrust provides a few ways to do these kinds of operations.

#include <thrust/host_vector.h>
#include <thrust/device_vector.h>

#include <thrust/copy.h>
#include <thrust/fill.h>
#include <thrust/sequence.h>

#include <iostream>

int main(void)
{
    
    thrust::device_vector<int> D(10, 1);

    
    thrust::fill(D.begin(), D.begin() + 7, 9);

    
    thrust::host_vector<int> H(D.begin(), D.begin() + 5);

    
    thrust::sequence(H.begin(), H.end());

    
    thrust::copy(H.begin(), H.end(), D.begin());

    
    for(int i = 0; i < D.size(); i++)
        std::cout << "D = " << D << std::endl;

    return 0;
}

Here we’ve illustrated use of the fill, copy, and sequence functions. The copy function can be used to copy a range of host or device elements to another host or device vector. Like the corresponding
STL function, thrust::fill simply sets a range of elements to a specific value. Thrust’s sequence function can be used to create a sequence of equally spaced values.

You’ll notice that we use things like thrust::host_vector or thrust::copy in our examples. The thrust:: part tells the C++ compiler that we want to look inside the thrust namespace for a specific function or class. Namespaces are a nice way to avoid name collisions. For instance, thrust::copy is different from std::copy provided in the STL. C++ namespaces allow us to distinguish between these two copy functions.

Fancy Iterators

Fancy iterators perform a variety of valuable purposes. In this section we’ll show how fancy iterators allow us to attack
a broader class of problems with the standard Thrust algorithms. For those familiar with the Boost C++ Library, note that our fancy iterators were inspired by (and generally derived from) those in the Boost Iterator Library.

Arguably the simplest of the bunch, constant_iterator is simply an iterator that returns the same value whenever we access it. In the following example we initialize a constant
iterator with the value 10.

#include <thrust/iterator/constant_iterator.h>
...

thrust::constant_iterator<int> first(10);
thrust::constant_iterator<int> last = first + 3;

first   
first   
first 


thrust::reduce(first, last);

Whenever an input sequence of constant values is needed, constant_iterator is a convenient and efficient solution.

If a sequence of increasing values is required, then counting_iterator is the appropriate choice. Here we initialize a counting_iterator with the value 10 and access it like an array.

#include <thrust/iterator/counting_iterator.h>
...

thrust::counting_iterator<int> first(10);
thrust::counting_iterator<int> last = first + 3;

first   
first   
first 


thrust::reduce(first, last);

While constant_iterator and counting_iterator act as arrays, they don’t actually require any memory storage. Whenever we dereference one of these iterators it generates
the appropriate value on-the-fly and returns it to the calling function.

In the Algorithms section we spoke about kernel fusion, i.e. combining separate algorithms like transform and reduce into a single transform_reduce operation. The transform_iterator allows us to apply the same technique, even when we don’t have a special transform_xxx version of the algorithm. This example shows another way to fuse a transformation with a reduction, this time with just plain
reduce applied to a transform_iterator.

#include <thrust/iterator/transform_iterator.h>

thrust::device_vector<int> vec(3);
vec = 10; vec = 20; vec = 30;


...
first = thrust::make_transform_iterator(vec.begin(), negate<int>());
...
last  = thrust::make_transform_iterator(vec.end(),   negate<int>());

first   
first   
first   


thrust::reduce(first, last);

Note, we have omitted the types for iterators first and last for simplicity. One downside of transform_iterator is that it can be cumbersome to specify the full type of the iterator, which can be quite lengthy. For this reason, it is
common practice to simply put the call to make_transform_iterator in the arguments of the algorithm being invoked. For example,


thrust::reduce(thrust::make_transform_iterator(vec.begin(), negate<int>()),
               thrust::make_transform_iterator(vec.end(),   negate<int>()));

allows us to avoid creating a variable to store first and last.

In the previous section we showed how transform_iterator is used to fuse a transformation with another algorithm to avoid unnecessary memory operations. The permutation_iterator is similar: it allows us to fuse gather and scatter operations with Thrust algorithms, or even other fancy iterators. The
following example shows how to fuse a gather operation with a reduction.

#include <thrust/iterator/permutation_iterator.h>

...


thrust::device_vector<int> map(4);
map = 3;
map = 1;
map = 0;
map = 5;


thrust::device_vector<int> source(6);
source = 10;
source = 20;
source = 30;
source = 40;
source = 50;
source = 60;



int sum = thrust::reduce(thrust::make_permutation_iterator(source.begin(), map.begin()),
                         thrust::make_permutation_iterator(source.begin(), map.end()));

Here we have used the make_permutation_iterator function to simplify the construction of the permutation_iterators. The first argument to make_permutation_iterator is the source array of the gather operation and the second is the list of map indices. Note that we pass in source.begin() for the first argument in both cases, but vary the second argument to define the beginning and end of the sequence.

When a permutation_iterator is used as an output sequence of a function it is equivalent to fusing a scatter operation to the algorithm. In general permutation_iterator allows you to operate on a specific set of values in a sequence instead of the entire sequence.

Intel

Итак, на сегодняшний день у компании Intel успехом пользуются 5 видов процессоров: Celeron, Pentium, Core i3, i5, и i7. Каждый из этих «камней» имеет разное количество ядер и предназначенные для разных задач. Например, Celeron имеет всего 2 ядра и используется в основном на офисных и домашних компьютерах. Pentium, или, как его еще называют, «пенек», также используется в дому, но уже имеет гораздо лучшую производительность, в первую очередь за счет технологии Hyper-Threading, которая «добавляет» физическим двум ядрам еще два виртуальных ядра, которые называют потоками. Таким образом, двухъядерный «проц» работает как самый бюджетный четырехъядерник, хотя это не совсем корректно сказано, но основная суть именно в этом.

Что же касается линейки Core, то тут примерно схожая ситуация. Младшая модель с цифрой 3 имеет 2 ядра и 2 потока. Линейка постарше — Core i5 — имеет уже полноценные 4 или 6 ядер, но лишена функции Hyper-Threading и дополнительных потоков не имеет, кроме как 4-6 стандартных. Ну и последнее — core i7 — это топовые процессоры, которые, как правило, имеют от 4 до 6 ядер и в два раза больше потоков, т. е., например, 4 ядра и 8 потоков или 6 ядер и 12 потоков.

Описание

Кристальные бабочки (при сборе которых получаются кристальные ядра) — один из «живых» материалов, которые вы можете собирать в Genshin Impact. Ресурс требуется для изготовления нескольких предметов, самым важным из которых является Густая смола. Найти кристальные ядра не так-то просто, если вы не знаете, где искать. Существует вероятность, что у вас уже есть несколько в вашем инвентаре, но если вы хотите их нафармить (насобирать большое количество), нужно создать хороший маршрут для фарма. Вот где найти кристальные ядра в Genshin Impact.

Поймать кристальную бабочку бывает сложно, так как они быстро улетают.

Как работает

Алгоритм вычислений выглядит следующим образом:

Хост выделяет на компьютере требуемое количество ОЗУ;
Он же копирует данные из собственной памяти в память графического ускорителя;
CPU запускает ядро на устройстве;
Видеокарта его обрабатывает;
Результаты копируются из RAM в память ЦП.

Так как GPU изначально разработаны под графические вычисления, что допускает параллельную обработку, то и CUDA в ряде случаев справится с задачей быстрее, чем сам центральный процессор. Все упирается в эффективность алгоритмов доступа к памяти устройства.

Сам центральный процессор, хотя тоже может обрабатывать данные несколькими ядрами одновременно, должен выполнять одну и ту же команду. В случае с видео платой таких ограничений нет, поэтому целесообразно делегировать этому компоненту часть полномочий по обработке информации.

Можно утверждать следующее:

Предельная мощность GPU при использовании CUDA в итоге будет больше, чем у CPU. Их архитектура изначально нацелена на выполнение задач по обработке текстур и сложных 3D много полигональных объектов, поэтому с числовыми данными видеоадаптер справится без особой нагрузки.

Единственный минус CUDA — пожалуй, то, что эта технология поддерживается только графическими чипами NVidia.

Также для вас будут полезны публикации «Сравниваем технологии Nvidia SLI и AMD CrossFire» и «Устанавливаем видеокарту вертикально и что для этого нужно». Буду признателен, если вы поделитесь этим постом в любой социальной сети — так вы можете поучаствовать в развитии моего блога. До скорой встречи!

Как посмотреть сколько ядер у процессора: диспетчер задач

Диспетчер задач предоставляет пользователю много полезной информации о компьютере, и в том числе может показать поверхностные данные об установленном процессоре. Для того, чтобы вызвать диспетчер задач, нажмите комбинацию клавиш Ctrl + Shift + ESC. после этого появится окно, в котором будут отображаться все запущенные процессы, которые потребляют ресурсы следующих компонентов ПК: процессор, оперативная память и жесткий диск. Кстати исходя из этой информации можно сделать вывод о том, насколько хорошо справляется с задачами ваш ЦПУ. Если вы столкнулись с высокой загрузкой процессора без видимой на то причины, то можете прочесть вот этот материал для того, чтобы устранить проблему.

Во второй вкладке «производительность» в нижней части окна вы увидите базовую информацию о процессоре, в том числе и количество ядер

Обратите внимание, что данные могут отображаться некорректно, если у вас установлена старая прошивка БИОС материнской платы, которая может быть плохо совместима с самыми свежими моделями ЦПУ. Мы часто сталкивались с подобной проблемой при работе с камнями Ryzen

Для того, чтобы получить достоверные данные необходимо обновить БИОС материнки до последней версии. Найти прошивку можно традиционно на официальном сайте разработчиков.

Как узнать размер ОЗУ вашего компьютера с помощью сторонних программ

Лично я, рекомендую пользоваться именно этим способом. Дальше вы поймете почему. Данный способ лучше тем, что с помощью сторонних программ, можно узнать гораздо больше информации об установленной ОЗУ.

Программ, показывающих характеристики оперативной памяти, существует много, к примеру, AIDA, но лучше использовать CPU-Z, в отличии от других программных обеспечений оно полностью бесплатное.

1. Производим запуск программы, а затем кликаем по надписи «Memory», тем самым переходя в данную вкладку.

Тут мы видим два раздела, а именно General и Timings. Первый предоставляет общую информацию об ОЗУ, с которой мы уже знакомы, а именно:

Тип памяти (в моём случае DDR3).
Объем памяти ОЗУ.
Канал, указывает какой режим использует ваша ОЗУ (одноканальный или двухканальный).
Частоту контроллера вашей памяти.

Второй раздел показывает частоту памяти в данный момент (DRAM Frequency). Данный показатель может быть ниже, чем заявлено в характеристиках, но это нормально. Увеличивается частота, благодаря использованию двухканального режима, но в данном пункте будет значиться фактическая частота.

2. Открываем вкладку «SPD». Она находится сразу после графы «Memory».

В данном окне, как и в прошлом, есть два раздела, но нам интересен только первый.

Здесь (в разделе Memory Slot Selection) можно выбрать каждый отдельный слот и получить подробную информацию о каждом из них, а именно:

Тип ОЗУ.
Максимальная частота памяти.
Производитель устройства.
Модель устройства.
Размер ОЗУ.
Напряжение оперативной памяти.

Где хранятся файлы ядра?

Где находится ядро Linux? Файлы ядра Ubuntu или любого другого Linux-дистрибутива находятся в папке /boot и называются vmlinuz-версия. Название vmlinuz походит с эпохи Unix. В шестидесятых годах ядра привыкли называть просто Unix, в 90-х годах Linux ядра тоже назывались — Linux.

Когда для облегчения многозадачности была разработана виртуальная память, перед именем файла появились буквы vm, чтобы показать что ядро поддерживает эту технологию. Некоторое время ядро называлось vmlinux, но потом образ перестал помещаться в память начальной загрузки, и был сжат. После этого последняя буква x была изменена на z, чтобы показать что использовалось сжатие zlib. Не всегда используется именно это сжатие, иногда можно встретить LZMA или BZIP2, поэтому некоторые ядра называют просто zImage.

Нумерация версии состоит из трех цифр, номер версии ядра Linux, номер вашей версии и патчи или исправления.

В паке /boot можно найти не только ядро Linux, такие файлы, как initrd.img и system.map. Initrd используется в качестве небольшого виртуального диска, который извлекает и выполняет фактический файл ядра. Файл System.map используется для управления памятью, пока еще ядро не загрузилось, а конфигурационные файлы могут указывать какие модули ядра включены в образ ядра при сборке.

На что влияет количество ядер процессора?

Многие путают понятие количества ядер и частоту процессора. Если это сравнивать с человеком, то мозг это процессор, нейроны — это ядра. Ядра работают не во всех играх и приложениях. Если в игре например выполняется 2 процесса, один вырисовывает лес, а другой город и в игре заложено многоядерность, то понадобиться всего 2 ядра, чтобы загрузить эту картинку. А если в игре заложено больше процессов, то задействуют все ядра.

И может быть наоборот, игра или приложение может быть написана так, одно действие может выполнять только одно ядро и в этой ситуации выиграет процессор, у которого выше частота и наиболее хорошо сложена архитектура (по этому обычно процессоры Интел чуть выигрывают Амд).

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

Функции ядер

Центральное ядро процессора выполняет 2 основных типа задач:

внутрисистемные;
пользовательские.

В первую категорию стоит отнести задачи по организации вычислений, загрузке интернет-страниц и обработке прерываний.

Во вторую же попадают функции поддержки приложений путем использования программной среды. Собственно, прикладное программирование как раз и построено на том, чтобы нагрузить ЦП задачами, которые он будет выполнять. Цель разработчика – настроить приоритеты выполнения той или иной процедуры.

Современные ОС позволяют грамотно задействовать все ядра процессора, что дает максимальную продуктивность системы. Из этого стоит отметить банальный, но логичный факт: чем больше физических ядер на процессоре, тем быстрее и стабильней будет работать ваш ПК.