Searched refs:memory (Results 1 - 25 of 25) sorted by path

/seL4-refos-master/apps/nethack/src/nethack-3.4.3/doc/
H A DGuidebook.tex1788 your memory of each spell will dim, and you will need to relearn it.
2737 NetHack should preload tiles into memory.
2740 enhances performance of the tile graphics, but uses more memory. (default on).
/seL4-refos-master/apps/nethack/src/nethack-3.4.3/include/
H A Dunixconf.h292 #include <memory.h>
/seL4-refos-master/projects/refos/design/
H A Dappendix.tex42 \subsection{Share a memory object}
74 \caption{Protocol for sharing a memory object from client A to client B.}
89 A box A [ label = "create memory object buffer X"];
90 A box A [ label = "create memory object for start and end index/pointer"];
112 A box A [ label = "create memory object buffer X"];
113 A box A [ label = "create memory object for start and end index/pointer"];
140 S box S [ label = "create a new memory object with mobject\_cap"];
248 requesting the pager to create an anonymous memory object
261 client B by another client to share the memory object anonymous
265 that can be used to accommodate the memory objec
[all...]
H A Dinterface.tex36 \item[\obj{dataspace}] is an object that represents a dataspace. The dataspace itself may represent anything that may be modeled as a series of bytes including devices, RAM and files. If something has access to a dataspace object, it may read from the dataspace object, write to the dataspace object and execute the dataspace object by mapping a memory window to the dataspace, closing the dataspace, or deleting the dataspace. Performing these operations is dependent on the dataspace permissions.
38 \item[\obj{memwindow}] is an object that represents an address space range (i.e. a memory window) segment in a process's virtual memory. If something has access to a memory window object, it may perform operations on the memory window object such as mapping the memory window to a dataspace and mapping a frame into the memory window.
51 The process server interface provides the abstraction for managing processes and threads. The abstraction includes management of processes' virtual memory, memory window creation and deletion, process creation and deletion, death notification of client processes and thread management. Note that in implementations \cp{procserv}{session} could be the same capability as \cp{procserv}{process} in which case the process server is connectionless. \cp{procserv}{session} may also be shared with \cp{procserv}{anon} for simplification.
70 Create a new memory windo
[all...]
H A Dintro.tex15 The overall design of \refOS revolves around the abstraction of a dataspace. A dataspace is a memory space (a series of bytes) representing anything from physical RAM to file contents on a disk to a device or even to a random number generator. The concept is analogous to UNIX files which may represent anything from \texttt{/usr/bin/sh} to \texttt{/dev/audio} to \texttt{/dev/urandom}.
17 The dataspace abstraction which dataspace servers provide paves the way for more complicated infrastructure such as sharing with complex trust relationships, memory management, file systems, and distributed naming. On top of this additional infrastructure, an operating system could implement features such as POSIX standard system calls, ports of existing software, drivers and display servers.
32 \texttt{Dataspaces} are abstractions over memory objects, analogous to UNIX files. A dataspace may be opened and closed, written to and read from, mapped into client memory and may represent a device, a file, or simply anonymous memory.
38 \texttt{Process servers} are servers which implement the process server interface and provide process abstraction. In practice, the process server may also need to implement additional interfaces and provide additional functionality in order for a system to start. For instance, in \refOS the process server also does naming and console input and output, implements the dataspace interface for anonymous memory and acts as the memory manager.
40 \texttt{Pagers} are servers which implement the pager service interface, which is very closely related to the dataspace interface and can be considered an optional feature of a dataspace server. Dataspace servers which act as pagers may have their dataspaces mapped directly into client virtual memory.
61 with at-least-once semantics (the bits are OR'd together). The asynchronous endpoint can be used to notify an untrusted client. To send messages (as opposed to just notifications) to an untrusted client, shared memory must be set up between the server and the client. Care must be taken to avoid unfavourable results like blocking and denial of service on shared memory buffer
[all...]
H A Dpaper.tex133 This document outlines a basic reference design for system components and interfaces for an operating system. The protocols have been designed with an \Lf like microkernel in mind and assume functionality such as interprocess communcation, capability-based access models and virtual memory support. This reference design aims to standardise the protocols for tasks often required to build a system such as resource sharing, virtual memory management and naming. Operating systems may implement these protocols and extend them to incorporate more features.
H A Dprotocol.tex109 \autoref{f:opendata} shows mapping an open dataspace into a given memory window. The initialisation sets up the components for sample fault delegation in the system. Note that the process server is acting as the memory manager. The paging could instead be implemented through a separate memory manager process.
198 In this example, the shared dataspace is implemented by the process server (acting as the memory manager) and is shared with a server. This is typical for a shared memory communication buffer.
405 A memory window should bookkeep its state, which vspace it belongs to, where and how long the memory segment is and the state of the memory window's contents. A memory window may be unmapped or mapped to a dataspace, and that dataspace may or may not be content initialised. In \refOS, the process server is the anonymous memory dataserve
[all...]
/seL4-refos-master/projects/refos/impl/apps/nethack/src/nethack-3.4.3/doc/
H A DGuidebook.tex1788 your memory of each spell will dim, and you will need to relearn it.
2737 NetHack should preload tiles into memory.
2740 enhances performance of the tile graphics, but uses more memory. (default on).
/seL4-refos-master/projects/refos/impl/apps/nethack/src/nethack-3.4.3/include/
H A Dunixconf.h292 #include <memory.h>
/seL4-refos-master/kernel/manual/parts/
H A Dapi.tex249 \ipcbloc{IPCBuffer[0]} & Amount of memory available in bytes\\
H A Dbootup.tex112 \texttt{seL4\_SlotRegion} & \texttt{untyped} & untyped-memory capabilities \\
169 Untyped memory is given in no particular order. The array entry
170 \texttt{untypedList[i]} stores the untyped-memory information of
174 memory information is stored in a \texttt{seL4\_UntypedDesc} struct, described
176 the memory backing the untyped. This allows userland to infer physical memory
179 memory being available.
H A Dcspace.tex44 managers of untyped memory to destroy the objects in that memory so it
61 that it will have, and this determines the amount of memory that it
63 memory and has the capacity to hold exactly one capability. This is 16
67 amount of untyped memory (see \autoref{sec:object_sizes}). The caller
68 must therefore have a capability to enough untyped memory as well as
125 When retyping untyped memory into objects with
255 all remaining in-kernel references and preparing the memory for
335 Like a virtual memory address, a capability address is simply an
336 integer. Rather than referring to a location of physical memory (a
[all...]
H A Dio.tex110 is bypassed when the device accesses memory. In seL4, device drivers run
113 access or corrupt memory that is not part of its address space, thus
115 the IOMMU on Intel x86-based platforms. An IOMMU allows memory to be
117 device, restricting the regions of system memory that it can access.
125 modify a device's memory mappings.
129 memory accesses.
187 devices that can initiate direct memory accesses (DMA).
189 An Arm SMMU v2.0 implementation allows device memory transactions to be associated
192 address translation, memory protection and memory attribut
[all...]
H A Dipc.tex25 memory called the \emph{IPC buffer}.
27 very short messages need not use the memory.
72 \texttt{badges} and \texttt{caps} use the same area of memory in
H A Dobjects.tex26 \item[Address spaces] are virtual memory spaces that each contain an
27 application. Applications are limited to accessing memory in their
331 \item[Untyped Memory] (see \autoref{sec:kernmemalloc}) is the foundation of memory allocation
332 in the seL4 kernel. Untyped memory capabilities have a single method
335 newly-created objects. Additionally, untyped memory objects can be
336 divided into a group of smaller untyped memory objects allowing
337 delegation of part (or all) of the system's memory. We discuss
338 memory management in general in the following sections.
345 The seL4 microkernel does not dynamically allocate memory for kernel objects.
346 Instead, objects must be explicitly created from application-controlled memory
[all...]
H A Dthreads.tex196 Like other objects, scheduling contexts are created from untyped memory using
306 thread raises a fault due to an unmapped virtual memory page, the thread cannot
H A Dvspace.tex12 virtual memory largely correspond to those of the hardware. Consequently,
14 Common to every architecture is the \obj{Page}, representing a frame of physical memory.
20 virtual memory address spaces. It should be noted that, as usual, the
21 manipulator of a virtual memory space needs the appropriate
34 or a specifically sized frame of memory, can be mapped. If the previous level is not mapped,
46 several other virtual-memory related object invocations.
148 A \obj{Page} object corresponds to a frame of physical memory that is used to
149 implement virtual memory pages in a virtual address space.
297 \texttt{seL4\_ARM\_ExecuteNever} & Map this memory as non-executable \\
300 \caption{\label{tbl:vmattr_arm} Virtual memory attribute
[all...]
/seL4-refos-master/kernel/src/arch/arm/machine/
H A Dgic_v2.c24 #error GIC_V2_DISTRIBUTOR_PPTR must be defined for virtual memory access to the gic distributer
31 #error GIC_V2_CONTROLLER_PPTR must be defined for virtual memory access to the gic cpu interface
225 #error GIC_V2_VCPUCTRL_PPTR must be defined for virtual memory access to the gic virtual cpu interface control
H A Dl2c_310.c222 #error L2CC_L2C310_PPTR must be defined for virtual memory access to the L2 cache controller
/seL4-refos-master/kernel/tools/hardware/
H A Ddevice.py13 from hardware.memory import Region
/seL4-refos-master/kernel/tools/hardware/outputs/
H A Dc_header.py14 from hardware.utils import memory, rule namespace
115 Groups is a list of 'KernelRegionGroups', each of which represents a single contiguous region of memory that is associated with a device.
165 physical_memory, reserved, physBase = memory.get_physical_memory(tree, config)
H A Delfloader.py18 from hardware.utils import cpu, memory, rule namespace
H A Dyaml.py7 ''' generate a yaml file with memory region info from the device tree '''
13 from hardware.utils import memory, rule namespace
31 phys_mem, reserved, _ = memory.get_physical_memory(tree, config)
33 dev_mem = memory.get_addrspace_exclude(list(reserved) + phys_mem + kernel_devs, config)
39 'memory': [{'start': r.base, 'end': r.base + r.size} for r in phys_mem if r.size > 0]
47 parser.add_argument('--yaml-out', help='output file for memory yaml',
/seL4-refos-master/kernel/tools/hardware/utils/
H A Dmemory.py14 from hardware.memory import Region
19 ''' Get all regions with device_type = memory in the tree '''
23 if node.has_prop('device_type') and node.get_prop('device_type').strings[0] == 'memory':
30 ''' Parse a reserved-memory node, looking for regions that are
59 memory region list, a set of any regions of memory that were aligned out
89 ''' returns a list of regions representing physical memory as used by the kernel '''
91 reserved = parse_reserved_regions(tree.get_path('/reserved-memory'))
H A Drule.py16 from hardware.memory import Region
38 ''' wraps a contiguous region of memory that is mapped into the kernel. '''

Completed in 244 milliseconds