/articles/toma

 The typical GPU consists of several semi-independent \emph{Streaming Multiprocessors (SM)} which share global GPU memory and L2 cache~\cite{nvidia2009gf110}. Several \emph{Direct Memory Access (DMA)} engines are included to move data to/from system memory. Each SM includes a task scheduler, computing units, a large register file, a fast on-chip (\emph{shared}) memory, and several different caches. There is a few types of computing units. The number crunching capabilities are provided by a large number of \emph{Arithmetic Units (ALU)} also called \emph{Core Units} by NVIDIA. ALUs are aimed on single-precision floating point and integer arithmetic. Some GPUs also include specialized \emph{half precision} and \emph{double precision} units to perform operations with these types faster. There are also architecture-specific units. All NVIDIA devices include \emph{Special Function Units (SFU)} which are used to quickly compute approximates of transcendent operations. The latest Volta architecture includes \emph{Tensor} units aimed on fast multiplication of small matrices to accelerate deep learning workloads~\cite{nvidia2017v100}. AMD architectures adapt scalar units to track loop counters, etc~\cite{amd2012gcn}. The memory operations are executed by \emph{Load/Store Units (LD/ST)}. The memory is either accessed directly or \emph{Texture} units are used to perform a fast linear interpolation between the neighboring data elements while loading the data. 

 The computing units are arranged in several SIMD sets which are able to execute the same instruction on multiple data elements simultaneously. Several such sets are included in SM and, often, can be utilized in parallel. The \emph{dispatch unit} of an SM employs data- and instruction-level parallelism to distribute the work-load between all available sets of SIMD units. However, it is architecture depended which combination of instructions can be executed in parallel. The ratio between throughput of different instructions and also shared memory bandwidth varies significantly. 

 There are 3 types of general-purpose memory provided by the GPU architecture. A large amount of \emph{global memory} is accessible to all threads of the task grid. Much smaller, but significantly faster \emph{shared memory} is local to a thread block. The thread-specific local variables are normally hold in registers. If there is not enough register space, a part of variables may be offloaded to \emph{local memory}. The thread-specific, but dynamically addressed arrays are always stored in the local memory (i.e. if array addresses can't be statically resolved during the compilation stage). In fact, the local memory is a special area of the global memory, but the data would normally not leave the L1 or L2 caches unless an extreme amount is required. Even then, access to variables in the local memory inflicts a severe performance penalty compared to the variables kept in the registers and should be avoided if possible.