Addressable Memory

Architecture

David Money Harris , Sarah Fifty. Harris , in Digital Design and Calculator Architecture (Second Edition), 2013

Memory

If registers were the merely storage space for operands, we would be confined to elementary programs with no more than than 32 variables. However, information can also be stored in memory. When compared to the annals file, memory has many data locations, merely accessing it takes a longer corporeality of time. Whereas the register file is small and fast, memory is big and slow. For this reason, commonly used variables are kept in registers. By using a combination of retentivity and registers, a program tin access a large corporeality of information fairly speedily. As described in Section 5.five, memories are organized as an array of data words. The MIPS architecture uses 32-scrap memory addresses and 32-bit data words.

MIPS uses a byte-addressable memory. That is, each byte in retentiveness has a unique accost. However, for explanation purposes just, nosotros first introduce a word-addressable memory, and afterward describe the MIPS byte-addressable memory.

Effigy half-dozen.1 shows a memory array that is word-addressable. That is, each 32-bit data word has a unique 32-bit address. Both the 32-scrap word accost and the 32-scrap data value are written in hexadecimal in Figure half dozen.1. For example, information 0xF2F1AC07 is stored at memory address 1. Hexadecimal constants are written with the prefix 0x. By convention, memory is drawn with depression retentivity addresses toward the bottom and high retentivity addresses toward the top.

Figure 6.1. Word-addressable memory

MIPS uses the load word teaching, lw, to read a data give-and-take from memory into a register. Code Example 6.6 loads memory give-and-take ane into $s3.

The lw instruction specifies the effective address in retentiveness every bit the sum of a base of operations address and an first. The base accost (written in parentheses in the education) is a register. The offset is a constant (written before the parentheses). In Code Example 6.6, the base address is $0, which holds the value 0, and the outset is ane, and so the lw instruction reads from memory address ($0 + ane) = one. After the load give-and-take instruction (lw) is executed, $s3 holds the value 0xF2F1AC07, which is the information value stored at memory address 1 in Effigy 6.1.

Code Example 6.6

Reading Give-and-take-Addressable Memory

Assembly Code

# This assembly lawmaking (unlike MIPS) assumes word-addressable memory

  lw $s3, one($0)   # read memory word one into $s3

Code Instance six.7

Writing Give-and-take-Addressable Memory

Assembly Lawmaking

# This assembly lawmaking (unlike MIPS) assumes word-addressable retentivity

  sw   $s7, 5($0)   # write $s7 to retentiveness word 5

Similarly, MIPS uses the store word instruction, sw, to write a data word from a register into memory. Code Instance 6.7 writes the contents of annals $s7 into retention discussion five. These examples take used $0 as the base address for simplicity, just retrieve that any register tin exist used to supply the base address.

The previous two code examples take shown a figurer compages with a word-addressable memory. The MIPS memory model, notwithstanding, is byte-addressable, not discussion-addressable. Each data byte has a unique address. A 32-chip discussion consists of iv 8-scrap bytes. So each word address is a multiple of iv, as shown in Figure six.two. Again, both the 32-chip give-and-take accost and the data value are given in hexadecimal.

Figure 6.two. Byte-addressable memory

Code Instance 6.eight shows how to read and write words in the MIPS byte-addressable retention. The word address is four times the word number. The MIPS assembly code reads words 0, ii, and three and writes words one, 8, and 100. The offset can exist written in decimal or hexadecimal.

The MIPS architecture too provides the lb and sb instructions that load and shop single bytes in retentiveness rather than words. They are similar to lw and sw and will be discussed farther in Section 6.4.five.

Byte-addressable memories are organized in a big-endian or footling-endian fashion, as shown in Figure half-dozen.three. In both formats, the well-nigh significant byte (MSB) is on the left and the least meaning byte (LSB) is on the correct. In big-endian machines, bytes are numbered starting with 0 at the big (most pregnant) end. In petty-endian machines, bytes are numbered starting with 0 at the little (least significant) stop. Give-and-take addresses are the aforementioned in both formats and refer to the same four bytes. Only the addresses of bytes inside a word differ.

Figure 6.3. Big- and little-endian retention addressing

Code Example 6.eight

Accessing Byte-Addressable Retentiveness

MIPS Assembly Lawmaking

lw   $s0,   0($0)   # read data discussion 0 (0xABCDEF78) into $s0

lw   $s1,   eight($0)   # read data word 2 (0x01EE2842) into $s1

lw   $s2,   OxC($0)   # read data word three (0x40F30788) into $s2

sw   $s3,   4($0)   # write $s3 to data word 1

sw   $s4,   0x20($0)   # write $s4 to data give-and-take eight

sw   $s5,   400($0)   # write $s5 to data word 100

Case 6.two

Large- and Fiddling-Endian Retention

Suppose that $s0 initially contains 0x23456789. Later on the post-obit program is run on a large-endian arrangement, what value does $s0 contain? In a lilliputian-endian system? lb $s0, one($0) loads the data at byte accost (1 + $0) = ane into the least significant byte of $s0. lb is discussed in detail in Section half dozen.four.5.

sw $s0, 0($0)

lb $s0, i($0)

Solution

Figure half-dozen.4 shows how big- and footling-endian machines store the value 0x23456789 in memory word 0. Later the load byte instruction, lb $s0, 1($0), $s0 would comprise 0x00000045 on a big-endian system and 0x00000067 on a petty-endian system.

Effigy 6.4. Big-endian and little-endian information storage

IBM'south PowerPC (formerly found in Macintosh computers) uses big-endian addressing. Intel'due south x86 architecture (found in PCs) uses little-endian addressing. Some MIPS processors are petty-endian, and some are big-endian. 1 The option of endianness is completely arbitrary only leads to hassles when sharing data between large-endian and little-endian computers. In examples in this text, we will employ little-endian format whenever byte ordering matters.

The terms large-endian and picayune-endian come from Jonathan Swift's Gulliver's Travels, first published in 1726 nether the pseudonym of Isaac Bickerstaff. In his stories the Little king required his citizens (the Little-Endians) to interruption their eggs on the little end. The Big-Endians were rebels who broke their eggs on the big cease.

The terms were first practical to computer architectures by Danny Cohen in his paper "On Holy Wars and a Plea for Peace" published on Apr Fools 24-hour interval, 1980 (USC/ISI IEN 137). (Photo courtesy of The Brotherton Drove, IEEDS University Library.)

In the MIPS architecture, discussion addresses for lw and sw must be word aligned. That is, the address must be divisible by 4. Thus, the instruction lw $s0, 7($0) is an illegal instruction. Some architectures, such as x86, allow non-word-aligned data reads and writes, but MIPS requires strict alignment for simplicity. Of form, byte addresses for load byte and store byte, lb and sb, need non be word aligned.

Read full chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9780123944245000069

Introduction

William J. Buchanan BSc, CEng, PhD , in Software Development for Engineers, 1997

13.six Retentiveness addressing size

The size of the accost bus indicates the maximum addressable number of bytes. Table 13.4 shows the size of addressable retentivity for a given address motorbus size. For example:

Table 13.4. Addressable memory (in bytes) related to address omnibus size

Address bus size Addressable memory (bytes)
1 2
2 iv
three viii
4 16
5 32
6 64
7 128
eight 256
ix 512
10 1K *
eleven 2K
12 4K
xiii 8K
14 16K
15 32K
xvi 64K
17 128K
xviii 256K
19 512K
xx 1M †
21 2M
22 4M
23 8M
24 16M
25 32M
26 64M
32 4G ‡
64 16GG
*
1K represents 1024
†
1M represents 1 048 576 (1024 K)
‡
1G represents i 073 741 824 (1024 G)
•

A 1-bit address bus can address upwards to ii locations (that is 0 and 1).

•

A 2-bit address passenger vehicle can accost ii2 or 4 locations (that is 00, 01, 10 and 11).

•

A 20-scrap address charabanc can address up to two20 addresses (i MB).

•

A 24-fleck address bus can accost up to sixteen MB.

•

A 32-bit address double-decker can accost upward to four GB.

Read full chapter

URL:

https://www.sciencedirect.com/scientific discipline/article/pii/B978034070014350058X

Embedded Software

Colin Walls , in Embedded Software (2nd Edition), 2012

1.3.two Flat Unmarried-Space Retentivity

Flat memory is conceptually the easiest compages to capeesh. Each memory location has an address, and each address refers to a single memory location. The maximum size of addressable memory has a limit, which is nearly probable to be defined past the word size of the scrap. Examples of chips applying this scheme are the Freescale Coldfire and the Zilog Z80.

Typically, addresses first at zero and get upward to a maximum value. Sometimes, particularly with embedded systems, the sequence of addresses may exist discontinuous. As long every bit the programmer understands the architecture and has the right development tools, this aperture is not a problem.

Most programming languages, like C, presume a flat memory. No special memory-handling facilities need be introduced into the language to fully use apartment memory. The simply possible bug are the use of address zilch, which represents a zero pointer in C, or high addresses, which may be interpreted equally negative values if care is not exercised.

Linkers designed for embedded applications that support microprocessors with flat retention architectures usually accommodate discontinuous memory space by supporting scatter loading of programme and data sections. The flat address memory architecture is shown in Effigy one.2.

Read full chapter

URL:

https://world wide web.sciencedirect.com/science/article/pii/B9780124158221000015

Estimator architecture

A.C. Fischer-Cripps , in Newnes Interfacing Companion, 2002

2.2.9 Microprocessor unit (MPU/CPU)

The central processing unit of measurement organises and orchestrates all activities inside the microcomputer. Each performance within the CPU is actually a very simple task involving the interaction of binary numbers and Boolean algebra. A big number of these simple tasks combine to form a particular function which may announced to exist alarmingly circuitous.

The "MPU" is substantially the aforementioned affair equally the more familiar and full general term "CPU" (CPU applies to whatsoever calculator, and not merely a microcomputer).

The CPU is responsible for initiating transferring data to and from memory and input/output devices, performing arithmetic and logical operations, and controlling the sequencing of all activities. Within the CPU are various subcomponents such as the arithmetics logic unit (ALU), the instruction decoder, internal registers and various command circuits which synchronise the timing of various signals on the buses.

CPU
Instruction decoder Accost registers
Arithmetic logic unit Pointers
Registers Flags
Education pointer

80X86 CPU development
1972 Intel introduces the 4004 with a four-fleck data bus, 10,000 transistors.
1974 8080 CPU has 8-fleck data bus and 64 kb addressable memory (RAM).
1978 8086 with a 16-fleck data autobus and i MB addressable memory, 4 MHz clock.
1979 8088 with 8 bit external data bus, 16-bit internal omnibus.
1982 80286, 24 bit address bus, 16 MB addressable memory, 6 MHz clock.
1985 80386DX with 32-bit data bus, ten MIPS, 33 MHz clock, 275 × ten3 transistors
1989 80486DX 32-bit data coach, internal maths coprocessor, >1 × 106 transistors, 30 MIPS, 100 MHz clock, iv GB addressable retentivity.
1993 Pentium, 64-chip PCI data motorcoach, 32-bit address motorbus, superscalar compages allows more than one instruction to execute in a unmarried clock wheel, hardwired floating point, >three × xhalf dozen transistors, 100 MIPS, >200 MHz clock, 4 GB addressable retentiveness.
1995 Pentium Pro, 64-fleck organisation motorbus, 5.v × 106 transistors, dynamic execution uses a speculative information menstruation analysis method to determine which instructions are ready for execution, 64 GB addressable retention.
1997 Pentium II, 7.5 × 10half-dozen transistors with MMX technology for video applications 64 GB addressable retentivity.
1999 Pentium III, 9.5 × 106 transistors, 600 MHz to i GHz clock.
2000 Pentium iv, 42 × 106 transistors, one.v GHz clock.
2001 Xeon, Celeron processors, one.2 GHz, 55 × 106 transistors.

Read total affiliate

URL:

https://www.sciencedirect.com/science/article/pii/B9780750657204501091

Configuring Windows Server Hyper-V and Virtual Machines

Aaron Tiensivu , in Securing Windows Server 2008, 2007

Understanding the Components of Hyper-V

Hyper-V has greater deployment capabilities to past versions and provides more options for your specific needs because information technology utilizes specific 64-bit hardware and a 64-bit operating organization. Additional processing ability and a larger addressable retentiveness space is gained by the utilization of a 64-bit environment. Hyper-V has three main components: the hypervisor, the virtualization stack, and the new virtualized I/O model. The hypervisor as well known equally the virtual motorcar monitor, is a very pocket-sized layer of software that is present directly on the processor, which creates the different "partitions" that each virtualized case of the operating organization will run within. The virtualization stack and the I/O components human action to provide a go-between with Windows and with all the partitions that y'all create. All three of these components of Hyper-V work together every bit a squad to allow virtualization to occur. Hyper-V hooks into threads on the host processor, which the host operating system can and then use to efficiently communicate with multiple virtual machines. Considering of this, these virtual machines and multiple virtual operating systems can all be running on a unmarried concrete processor. You tin can come across this model in Figure 8.i.

Figure 8.i. Viewing the Components of Hyper-V

Tools & Traps…

Understanding Hypercalls in Hyper-V

In society to better understand and distinguish the ground for Hyper-V virtualization, let'south try to become a better idea of how hypercalls work. The hypervisor uses a calling system for a invitee that is specific to Hyper-V. These calls are called hypercalls. A hypercall defines each set up of input or output parameters betwixt the host and guest. These parameters are referred to in terms of a memory-based data structure. All aspects of input and output data structures are cushioned to natural boundaries up to 8 bytes. Input and output data structures are placed in memory on an viii-byte boundary. These are and so padded to a multiple of 8 bytes in size. The values inside the padding areas are overlooked past the hypervisor.

There are two kinds of hypercalls referred to as simple and repeat. Simple hypercall attempts a single act or operation. Information technology contains a fixed-size set of input and output parameters. Repeat hypercall conducts a complicated series of uncomplicated hypercalls. Likewise having the parameters of a elementary hypercall, a repeat hypercall uses a listing of fixed-size input and output elements.

You tin can result a hypercall only from the almost privileged guest processor fashion. For x64 surroundings, this means the protected fashion with the Current Privilege Level (CPL) of zero. Hypercalls are never immune in real mode. If you attempt to issue a hypercall within an illegal processor mode, y'all volition receive an undefined operation exception.

All hypercalls should be issued via the architecturally defined hypercall interface. Hypercalls issued by other means including copying the code from the hypercall code page to an alternate location and executing it from at that place could effect in an undefined performance exception. You should avoid doing this altogether because the hypervisor is not guaranteed to deliver this exception.

The hypervisor creates partitions that are used to isolate guests and host operating systems. A segmentation is comprised of a physical address space and one or more virtual processors. Hardware resources such equally CPU cycles, memory, and devices tin can be assigned to the sectionalisation. A parent division creates and manages child partitions. It contains a virtualization stack, which controls these kid partitions. The parent sectionalisation is in about occasions also the root division. It is the first partitioning that is created and owns all resources not owned by the hypervisor. Equally the root sectionalisation information technology will handle the loading of and the booting of the hypervisor. Information technology is likewise required to bargain with ability direction, plug-and-play, and hardware failure events.

Partitions are named with a sectionalisation ID. This 64-bit number is delegated past the hypervisor. These ID numbers are guaranteed by the hypervisor to be unique IDs. These are not unique in respect to power cycles however. The aforementioned ID may be generated across a ability cycle or a reboot of the hypervisor. The hypervisor does guarantee that all IDs within a single power wheel will be unique.

The hypervisor as well is designed to provide availability guarantees to guests. A group of servers that take been consolidated onto a solitary physical machine should non hinder each other from making progress, for example. A partition should be able to be run that provides telephony support such that this partitioning continues to perform all of its duties regardless of the potentially contrary actions of other partitions. The hypervisor takes many precautions to assure this occurs flawlessly.

For each partition, the hypervisor maintains a retentivity pool of RAM SPA pages. This puddle acts just similar a checking account. The amount of pages in the pool is called the residuum. Pages are deposited or withdrawn from the memory pool. When a hypercall that requires retentivity is made by a sectionalisation, the hypervisor withdraws the required memory from the full pool residual. If the balance is insufficient, the call fails. If such a withdrawal is made by a guest for another guest in some other partition, the hypervisor attempts to draw the requested corporeality of retentiveness from the pool of the latter sectionalization.

Pages inside a partition'southward retentiveness pool are managed by the hypervisor. These pages cannot be accessed through any sectionalization's Global Presence Architecture (GPA) space. That is, in all partitions' GPA spaces, they must be inaccessible (mapped such that no read, write or execute admission is allowed). In full general, the only sectionalization that can deposit into or withdraw from a partition is that partitioning'south parent.

Warning

Retrieve non to confuse partitions with virtual machines. You should think of a virtual automobile every bit comprising a sectionalisation together inside its state. Many times segmentation can be mistaken for the deed of virtualization when dealing with Hyper-Five.

We should note that Microsoft will continue to support Linux operating systems with the production release of Hyper-V. Integration components and technical support will be provided for customers running certain Linux distributions equally guest operating systems inside Hyper-V. Integration components for Beta Linux are now available for Novell SUSE Linux Enterprise Server (SLES) 10 SP1 x86 and x64 Editions. These components enable Xen-enabled Linux to take reward of the VSP/VSC architecture. This will assistance to provide improved performance overall. Beta Linux Integration components are bachelor for immediate download through http://connect.microsoft.com. Another additionally noteworthy feature is, as of this writing, Red Hat Fedora 8 Linux and the alpha version of Fedora 9 Linux, which are both compatible and supported by Hyper-Five. The full list of supported operating systems volition be announced prior to RTM.

Read full chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9781597492805000080

GPU Application Development, Debugging, and Performance Tuning with GPU Ocelot

Andrew Kerr , ... Sudhakar Yalamanchili , in GPU Calculating Gems Jade Edition, 2012

thirty.2.1 PTX Functional Simulation

Ocelot's PTX emulator models a virtual architecture illustrated in Figure thirty.2 . This backend implements the NVIDIA PTX execution model and emulates the execution of a kernel on a GPU past interpreting instructions for each active thread of a warp earlier fetching the next teaching. This corresponds to execution by an arbitrarily broad single-instruction multiple-data (SIMD) processor and is similar to how hardware implementations such as NVIDIA's GeForce 400 series GPUs execute CUDA kernels. Blocks of retentivity store values for the virtual register file too as the addressable memory spaces. The emulator interprets each didactics according to opcode, data type, and modifiers such as rounding or clamping modes, updating the architectural country of the processor with computed results.

Figure 30.2. PTX emulator virtual compages.

Kernels executed on the PTX emulator present the entire observable state of a virtual GPU to user-extensible instruction trace generators. These are objects implementing an interface that receives the complete internal representation of a PTX kernel at the time it is launched for initial analysis. So, as the kernel is executed, a trace result object is dispatched to the drove of active trace generators after each didactics completes. This trace effect object includes the instruction's internal representation and PC, set of retentiveness addresses referenced, and thread ID. At this point, the instruction trace generator has the opportunity to inspect the register file and retentiveness spaces accessible by the GPU such as shared and local retentiveness. Practically whatever observable behavior may be measured using this arroyo. In the next department, we volition discuss Ocelot's interfaces for user-extended trace generators that compute custom metrics.

Read total chapter

URL:

https://www.sciencedirect.com/scientific discipline/article/pii/B9780123859631000307

Trinity workloads

Jim Jeffers , ... Avinash Sodani , in Intel Xeon Phi Processor High Operation Programming (Second Edition), 2016

Running Trinity on Knights Landing: Quadrant-Flat vs Quadrant-Cache

Let united states of america now consider flat memory mode with quadrant cluster mode (quadrant-flat for short), and how that compares to quadrant-enshroud . To change to this mode, we accept to reboot with modified BIOS options. The cluster mode remains the same, simply now MCDRAM is treated every bit addressable memory and tin can be accessed via a separate NUMA node. If we run the command numactl --hardware, two NUMA nodes volition exist shown (meet Fig. 25.viii). The CPUs and DDR memory are in node 0, and MCDRAM is in node ane. If we run the workload without using numactl, for example, mpirun –np 68 ./myKNLwkld, the workload uses memory from the nearest NUMA node beginning (node 0 in this case, i.eastward., DDR retention). Defining the NUMA nodes such that the NUMA altitude betwixt the MCDRAM and the CPUs is greater than the distance between the DDR and the CPUs is done so that we have to explicitly specify when MCDRAM is used. There a few different means to use MCDRAM in apartment mode.

Fig. 25.8. Apartment mode showing two separate NUMA nodes when executing  numactl -hardware.

▪

Use numactl –-membind ane to bind the workload to NUMA node 1

❐

For instance: numactl –-membind ane ./myScriptToRunOnKNL.sh

Past binding the workload, the workload is forced to employ only the retentiveness designated past that NUMA node (in this case, MCDRAM). If you demand more than the MCDRAM memory size, the workload will crash. For case, GTC requires 32   GB to run on a single node. Thus, GTC cannot exist run but out of MCDRAM.

▪

Use numactl –-preferred 1 to adopt NUMA node 1

Now the workload will attempt to employ MCDRAM first only will not crash if the memory required is greater than MCDRAM size; this provides a safety net in case retentiveness footprint becomes slightly larger than MCDRAM chapters.

▪

memKind library (hbwmalloc)—this library enables users to specify which arrays or other blocks of memory should be allocated in MCDRAM.

Tools can aid with apartment manner:

▪

Intel® VTune™ Amplifier Retention Object Assay—determines dynamic and static memory objects and their performance touch to identify candidate data structures for MCDRAM allocation.

▪

autohbw—Interposer library that comes with memkind. Finds retentivity allocation calls and automatically allocates retentivity in MCDRAM if allocation is greater than a given threshold.

Figs. 25.9 and 25.10 show operation of the same 5 workloads previously plotted in Fig. 25.4; dashed lines indicate quadrant-cache results, and solid lines point quadrant-flat results using numactl --preferred one.

Fig. 25.ix. MiniFE and MiniGhost performance in quadrant-apartment and quadrant-enshroud.

Fig. 25.ten. AMG, UMT, and SNAP performance in quadrant-apartment vs quadrant-cache.

MiniGhost performance is very interesting; at lower trouble sizes (<   16   GB) flat mode is meliorate, just at larger trouble sizes (>   16 GB), cache mode is better. This performance drop is due to limitations of numactl --preferred 1, using other methods to allocate specific retentiveness blocks into MCDRAM such as memkind library may improve functioning. MiniGhost bandwidth measurements bear witness the larger problem sizes in quad apartment have minimal MCDRAM use when run with numactl --preferred ane.

Retentivity bandwidth was measured to show how bandwidth changes for MiniGhost and MiniFE at different trouble sizes. At the xvi   GB problem size, MiniGhost in quadrant-cache has MCDRAM bandwidth of 312   GB/s and DDR bandwidth of 15   GB/s. At the 64   GB trouble size, MiniGhost in quadrant-cache has MCDRAM bandwidth of 214   GB/south and DDR bandwidth of 65   GB/south. In contrast, MiniGhost in quadrant-flat at 64   GB problem size has MCDRAM bandwidth of 0   GB/southward and DDR bandwidth of 88   GB/s. Although, we chosen MiniGhost cache unfriendly due to the "sweet spot" beliefs, the workload is still benefiting from MCDRAM cache at big problem sizes in quadrant-cache. MiniFE at large problem sizes does non benefit from MCDRAM every bit enshroud. At 16   GB trouble size, MiniFE has 267   GB/s MCDRAM bandwidth and 31   GB/s DDR bandwidth. However, at 57   GB trouble size, MiniFE in quadrant-enshroud has 16   GB/s MCDRAM bandwidth and 78   GB/due south DDR bandwidth. MiniFE performance at large problem sizes is limited by DDR retention bandwidth.

UMT and AMG are very enshroud-friendly workloads at small and big problem sizes. However, performance drops at larger problem sizes when using apartment mode as the workload'southward allocated information no longer fits in MCDRAM. SNAP performs better with flat manner at larger problem sizes. SNAP suffers from MCDRAM cache aliasing on large trouble sizes similar to MiniGhost at small problem sizes. Still in flat mode, in that location is no aliasing, enabling SNAP to perform better at large problem sizes and MiniGhost to perform better at small problem sizes compared to cache style.

Consider using flat mode under the following atmospheric condition:

▪

Problem size does not fit in 16-GB MCDRAM and workload is latency bound instead of being bandwidth limited: DDR latency in flat fashion volition be lower than MCDRAM latency in cache mode if there are excessive MCDRAM enshroud misses. (meet Chapters four and 6 Chapter 4 Chapter 6 )

▪

Workload uses total enshroud-line streaming stores or partial cache-line (eastward.chiliad., SSE/AVX ISA) streaming stores

❐

Streaming stores bypass core cpu-caches and update memory directly, only MCDRAM is a retentivity-side cache (whenever it is operated as a cache) and cannot be bypassed. MCDRAM cache incurs additional overhead to handle streaming stores: it requires one actress retention read to determine whether a line is already present in MCDRAM (fractional enshroud-line write may also require an actress retentivity write to fill the line from retention in example of a miss). Hence, if a workload is probable to take a large number of streaming stores, then it may be better to configure MCDRAM as flat, since MCDRAM as flat memory does not have such overheads because it is straight addressable memory same every bit DDR memory.

▪

Workload is significantly affected by cache aliasing in cache mode (example: SNAP and MiniGhost). MCDRAM is a direct-mapped enshroud which means memory accesses that map to aforementioned MCDRAM cache-line will conflict causing evictions of data being used and increased disharmonize misses which will bear upon operation (see Fig. 25.11)

❐

With a direct-mapped cache, chapters misses will occur when the working set size is greater than MCDRAM chapters (as in SNAP case). However, disharmonize misses can likewise occur with modest trouble sizes (less than MCDRAM capacity) depending on where data is allocated in physical retentiveness (as we observed in the MiniGhost case).

Fig. 25.11. Cache line conflict occurs on Knights Landing with a 16   GB MCDRAM cache if bits 6 to 33 of concrete address match. Increased MCDRAM cache misses due to conflicts will touch functioning.

Performance comparison betwixt cache mode and flat mode with respect to thread scaling is shown in Fig. 25.12. AMG and UMT are two of our cache-friendly workloads; equally such, these workloads have better scaling in cache manner than in flat mode. SNAP and GTC in contrast accept ameliorate scaling in flat way.

Fig. 25.12. Multiple threads per core scaling in quadrant-flat vs quadrant-cache; Y-centrality is speedup over respective mode's single-thread performance.

Fig. 25.13 includes the best performance of all viii Trinity workloads, where best performance was selected betwixt quadrant-enshroud and quadrant-flat, varying problem size, and varying hardware threads per core. Some workloads perform better in quadrant-enshroud and others in quadrant-flat.

Fig. 25.13. All-time functioning of all 8 Trinity workloads when considering quadrant-cache and quadrant-flat.

Hybrid mode

Knights Landing's hybrid manner combines cache mode with flat mode (see Fig. 25.14). This enables avant-garde optimizations where users tin can specify which data should be allocated in MCDRAM in flat mode via the memkind library (hbwmalloc calls, run into Affiliate 3), and it besides enables a smaller retention-side enshroud for remaining data. The baseline versions of the Trinity workloads are not optimized for this mode as no source code changes were done. However, keep in mind that this is an selection to consider when optimizing workloads for Knights Landing.

Fig. 25.14. Hybrid mode, role of MCDRAM, is addressable retention and part is retention-side cache.

Read full chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9780128091944000259

MEMORY PROTECTION UNITS

ANDREW N. SLOSS , ... CHRIS WRIGHT , in ARM Arrangement Developer's Guide, 2004

xiii.3.two ASSIGNING REGIONS USING A MEMORY MAP

The last column of Table 13.ten shows the four regions we assigned to the memory areas. The regions are divers using the starting address listed in the table and the size of the lawmaking and data blocks. A memory map showing the region layout is provided in Figure xiii.7.

Figure 13.7. Region consignment and retentiveness map of demonstration protection organisation.

Region ane is a background region that covers the entire addressable memory space. Information technology is a privileged region (i.e., no user mode access is permitted). The instruction enshroud is enabled, and the data cache operates with a writethrough policy. This region has the everyman region priority because it is the region with the lowest assigned number.

The master function of region 1 is to restrict access to the 64 KB space between 0×0 and 0×10000, the protected system area. Region 1 has ii secondary functions: it acts as a groundwork region and as a protection region for dormant user tasks. As a background region it ensures the entire retentiveness space by default is assigned system-level access; this is done to prevent a user task from accessing spare or unused retentiveness locations. As a user task protection region, it protects fallow tasks from misconduct by the running task (see Effigy 13.vii).

Region 2 controls access to shared system resources. Information technology has a starting address of 0×10000 and is 64 KB in length. It maps direct over the shared retentivity space of the shared system code. Region 2 lies on top of a portion of protected region one and will take precedence over protected region 1 because it has a higher region number. Region two permits both user and organization level retentiveness access.

Region 3 controls the retentiveness surface area and attributes of a running task. When control transfers from 1 task to another, equally during a context switch, the operating system redefines region 3 so that information technology overlays the memory area of the running job. When region 3 is relocated over the new task, information technology exposes the previous task to the attributes of region ane. The previous task becomes role of region i, and the running task is a new region 3. The running task cannot access the previous task because it is protected by the attributes of region one.

Region iv is the memory-mapped peripheral system infinite. The main purpose of this region is to establish the area as not buried and not buffered. We don't desire input, output, or control registers subject area to the stale data issues caused by caching, or the fourth dimension or sequence issues involved when using buffered writes (see Chapter 12 for details on using I/O devices with caches and write buffers).

Read full chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9781558608740500149

Busses, Interrupts and PC Systems

William Buchanan BSc (Hons), CEng, PhD , in Computer Busses, 2000

2.1.3 Address bus

The address double-decker is responsible for identifying the location into which the data is to be passed into. Each location in retentivity typically contains a single byte (8 bits), but could also be bundled as words (16 bits), or long words (32 $.25). Byte-oriented memory is the most flexible every bit it as well enables access to any multiple of eight bits. The size of the accost bus thus indicates the maximum addressable number of bytes. Table 2.3 shows the size of addressable retentivity for a given accost double-decker size. The number of addressable bytes is given past:

Addressable locations = two n bytes

Addressable locations for a given accost passenger vehicle size

where n is the number of $.25 in the address jitney. For example:

•

A 1-chip accost motorcoach can address upwardly to two locations (that is 0 and 1).

•

A 2-scrap address bus can address ii2 or 4 locations (that is 00, 01, ten and 11).

•

A 20-bit address motorcoach can address upward to ii20 addresses (1   MB).

•

A 32-bit address bus tin can accost up to 232 addresses (4GB).

The units used for computers for defining retentiveness are B (Bytes), kB (kiloBytes), MB (megaBytes) and GB (gigabytes). These are defined as:

•

KB (kiloByte). This is divers as 210 bytes, which is 1024 B.

•

MB (megaByte). This is defined as 220 bytes, which is 1024 kB, or 1 048 576 bytes.

•

GB (gigaByte). This is divers as twoxxx bytes, which is 1024   MB, or 1048576 kB, or 1073 741 824 B.

Table two.1 gives a table with addressable space for given address bus sizes.

Table 2.1. Addressable memory (in bytes) related to accost bus size

Address bus size Addressable memory (bytes) Address bus size Addressable retention (bytes)
1 two 15 32   K
2 4 16 64   Chiliad
3 8 17 128   K
four sixteen 18 256   Thousand
v 32 xix 512   K
half dozen 64 20 1 M †
7 128 21 2   M
8 256 22 4   M
9 512 23 8   Thou
10 1 K* 24 16   Thou
xi 2   K 25 32   M
12 four   K 26 64   M
13 8   K 32 4 Thou ‡
xiv sixteen   M 64 sixteen GG
*
i   K represents 1024
†
1M represents 1 048 576 (1024   G)
‡
1G represents 1 073 741 824 (1024   M)

Information handshaking

Handshaking lines are also required to allow the orderly flow of information. This is illustrated in Effigy 2.4. Ordinarily there are several unlike types of busses which connect to the system, these different busses are interfaced to with a bridge, which provides for the conversion between one type of bus and some other. Sometimes devices connect directly onto the processor'due south motorbus; this is called a local bus, and is used to provide a fast interface with directly access without any conversions.

Effigy 2.4. Estimator double-decker connections

The most bones type of handshaking has two lines:

•

Sending identification line – this identifies that a device is ready to ship data.

•

Receiving identification line – this identifies that device is a device is ready to receive data, or not.

Figure 2.5 shows a simple form of handshaking of data, from Device 1 to Device ii. The sending status is identified past Prepare? and the receiving status past Condition. Commonly an issue is identified past a signal line moving from i state to another, this is described equally edge-triggered (rather than level-triggered where the actual level of the signal identifies its state). In the example in Figure 2.v, initially Device one puts data on the data passenger vehicle, and identifies that information technology is ready to transport information past irresolute the Set up? line from a Depression to a High level. Device 2 then identifies that it is reading the data by irresolute its STATUS line from a Depression to a HIGH. Next it identifies that it has read the data by changing the Status line from a HIGH to a Depression. Device ane can and so put new data on the data autobus and first the bike over again by changing the Fix? line from a LOW to a High.

Figure 2.five. Simple handshaking of information

This blazon of communication only allows advice in one direction (from Device 1 to Device 2) and is know every bit simplex communications. The main types of communication are:

•

Simplex communication. Just one device can communicate with the other, and thus just requires handshaking lines for one management.

•

One-half-duplex communication. This allows communications from one device to the other, in whatever management, and thus requires handshaking lines for either direction.

•

Full-duplex communications. This allows communication from one device to another, in either management, at the same time. A practiced example of this is in a telephone system, where a caller can transport and receive at the same fourth dimension. This requires separate transmit and receive data lines, and separate handshaking lines for either management.

Command lines

Control lines define the performance of the data transaction, such as:

•

Information flow management – this identifies that data is either being read from a device or written to a device.

•

Retentiveness addressing blazon – this is typically either past identifying that the address access is straight retentiveness accessing or indirect retentivity access. This identifies that the address on the bus is either a existent memory location or is an address tag.

•

Device arbitration – this identifies which device has command of the autobus, and is typically used when there are many devices connected to a common bus, and whatever of the devices are allowed to communicate with any other of the devices on the jitney.

Read full chapter

URL:

https://www.sciencedirect.com/science/article/pii/B978034074076750002X

Mass Storage

Lucio Di Jasio , in Programming sixteen-Chip Movie Microcontrollers in C (2nd Edition), 2012

Using the SD/MMC Interface Module

Whether you believe it or not, the six minuscule routines we take just developed are all nosotros demand to gain access to the seemingly unlimited amount of storage space offered by the SD/MMC memory cards. For example, a 512 Mbyte card would provide us with approximately 1,000,000 (yes that is i million) individually addressable retentivity blocks (sectors) each 512 bytes big. Note that, as of this writing, SD/MMC cards of this capacity are normally offered for retail in the United states of america for less than $5!

Let's develop a small test program to demonstrate the use of the SD/MMC module. The idea is to simulate a somewhat typical application that is required to save some big amount of data on the SD/MMC memory card. A fixed number of blocks of data will be written in a predetermined range of addresses and and then read back to verify the successful completion of the process.

Let's create a new source file that we will telephone call SDMMCTest.c and outset by calculation the usual config.h file followed past the SDMMC.h include file.

/*

** SDMMCTest.c

**

** Read/write Test

*/

#include <configure.h>

#include <EX16.h>

#include <SDMMC.h>

Than let'south ascertain two byte arrays each the size of a default SD/MMC retention cake, that is 512 bytes.

#define B_SIZE512  // sector/data block size

unsigned char information   [B_SIZE];

unsigned charbuffer   [B_SIZE];

The exam program will fill the first with a specific and easy to recognize pattern, and will repeatedly write its contents onto the memory carte du jour. The chosen address range will be defined past ii constants:

#define START_ADDRESS10000// start cake address

#define N_BLOCKS    g// number of blocks

The LEDs on PORTA of the Explorer16 demonstration lath will provide u.s.a. with a visual feedback about the right execution of the plan and/or whatever error encountered.

The first few lines of the main program tin can now exist written to initialize the I/Bone required by the SD/MMC module and the PORTA pins connected to the row of LEDs.

master(void)

{

LBA addr;

int i, r;

// I/O initializations

TRISA = 0;// initialize PORTA LED outputs

InitSD();  // initialize I/Os required for the SD/MMC bill of fare

// fill the buffer with "data"

for(i=0; i<B_SIZE; i++)

  data[i] = i;

The next code segment will accept to check for the presence of the SD carte in the slot/connector. We will wait in a loop for the carte detection switch if necessary and we will provide an additional delay for the contacts to properly debounce.

// wait for carte to exist inserted

while(!DetectSD())// assumes SDCD pin is by default an input

  Delayms(100);// look for carte du jour contacts de-bounce and ability upwards

Nosotros will be generous with the debouncing delay as we want to make certain that the card connection is stable before we offset firing write commands that could otherwise potentially corrupt other data present on the card. A 100   ms delay is a reasonable delay to use and the Delayms() function is taken from the EX16.h library module divers in before chapters.

Keeping the de-bouncing delay part separate from the DetectSD() role and the SD/MMC module in general is important as this will allow unlike applications to selection and choose the all-time timing strategy and optimize the resources allocation.

One time nosotros are sure that the menu is present, we can proceed with its initialization, calling the InitMedia() function.

// initialize the memory card (returns 0 if successful)

r = InitMedia();

if (r)    // could not initialize the carte

{

  PORTA = r;  // show error code on LEDs

  while(i);  // halt hither

}

The function returns an integer value, which is zero for a successful completion of the initialization sequence, or a specific error code otherwise. In our test programme, in the instance of an initialization error we will merely publish the error code on the LEDs and halt the execution entering an infinite loop. The codes 0x84 and 0x85 will indicate that respectively the InitMedia() function steps 4 or 5 have failed, corresponding to an incorrect execution of the bill of fare RESET control and carte INIT commands (failure or timeout) respectively.

If all goes well we will be able to go on with the actual data writing phase.

else

{

  // fill up N_BLOCK blocks/SECTOR with the contents of data buffer

  addr = START_ADDRESS;

  for(i=0; i<N_BLOCKS; i++)

  if (!WriteSECTOR(addr+i, information))

  {// writing failed

    PORTA = 0x0f;

    while(1);// halt hither

  }

The simple for loop performs repeatedly the WriteSECTOR() part over the address range from block ten,000 to block 10,999, copying over and over the aforementioned data block and verifying at each step that the write control is performed successfully. If any of the cake write commands returns an error, a unique code (0x0f) volition be presented on the LEDs and the execution will exist halted. In practise this will be equivalent to writing a file of 512,000 bytes.

  // verify the contents of each block/SECTOR written

  addr = START_ADDRESS;

  for(i=0; i<N_BLOCKS; i++)

  {// read dorsum ane cake at a time

    if (!ReadSECTOR(addr+i, buffer))

    {// reading failed

    PORTA = 0xf0;

    while(one);// halt here

  }

  // verify each block content

    if (memcmp(data, buffer, B_SIZE))

    {// mismatch

    PORTA = 0x55;

    while(i); // halt here

    }

  } // for each block

Side by side we will commencement a new loop to read dorsum each data cake into the 2nd buffer and we will compare its contents with the original pattern still available in the commencement buffer. If the ReadSECTOR() part should fail, we will present an error lawmaking (0xf0) on the LED display and terminate the test. Otherwise, a standard C library part memcmp() will help us perform a fast comparison of the buffer contents, returning an integer value that is zero if the two buffers are identical as we hope, non zip otherwise. Once more, a new unique error indication (0x55) will be provided if the comparison should neglect. To gain access to the memcmp() role that belongs to the standard C string.h library.

We can now consummate the primary program with a final indication of successful execution, lighting up all LEDs on PORTA.

} // else media initialized

// indicate successful execution

PORTA = 0xFF;

// main loop

while(1);

} // principal

If you have added all the required source files SDMMC.h , EX16.h , EX16.c , SDMMC.c and SDMMCTest.c to the projection, y'all tin can now launch the project by using the Run>Run Projection command. You will need a daughter board with the SD/MMC connections as described at the kickoff of the lesson to actually perform the test. Just the effort of edifice 1 (or the expense of purchasing ane) will exist more than compensated for by the joy of seeing the PIC24 perform the test flawlessly in a fraction of a second. The amount of lawmaking required was besides impressively small (Figure thirteen.7).

Figure 13.7. MPLAB® C compiler memory usage report

Altogether, the test program and the SDMMC access module have used up only 1,374 bytes of the processor FLASH program memory, that is, less than 1% of total memory available, and 1,104 bytes of RAM (2×512 buffers+stack), which is less than 15% of the total RAM retentivity bachelor. As in all previous lessons this event was obtained with the compiler optimization options set to level 1, bachelor in the costless evaluation version of the compiler.

Read full chapter

URL:

https://world wide web.sciencedirect.com/science/article/pii/B9781856178709000130