StarPU Internal Handbook
Loading...
Searching...
No Matches
_starpu_node Struct Reference

Data Fields

struct _starpu_spinlock mc_lock
 
struct _starpu_mem_chunk_list mc_list
 
struct _starpu_mem_chunk * mc_dirty_head
 
unsigned mc_nb
 
unsigned mc_clean_nb
 
struct mc_cache_entry * mc_cache
 
int mc_cache_nb
 
starpu_ssize_t mc_cache_size
 
unsigned tidying
 
unsigned reclaiming
 
volatile int prefetch_out_of_memory
 
unsigned evictable
 
struct _starpu_data_request_prio_list data_requests [STARPU_MAXNODES][2]
 
struct _starpu_data_request_prio_list prefetch_requests [STARPU_MAXNODES][2]
 
struct _starpu_data_request_prio_list idle_requests [STARPU_MAXNODES][2]
 
starpu_pthread_mutex_t data_requests_list_mutex [STARPU_MAXNODES][2]
 
struct _starpu_data_request_prio_list data_requests_pending [STARPU_MAXNODES][2]
 
unsigned data_requests_npending [STARPU_MAXNODES][2]
 
starpu_pthread_mutex_t data_requests_pending_list_mutex [STARPU_MAXNODES][2]
 
int malloc_on_node_default_flags
 
struct _starpu_chunk_list chunks
 
int nfreechunks
 
starpu_pthread_mutex_t chunk_mutex
 
size_t global_size
 
size_t used_size
 
size_t waiting_size
 
starpu_pthread_mutex_t lock_nodes
 
starpu_pthread_cond_t cond_nodes
 
char padding [STARPU_CACHELINE_SIZE]
 

Field Documentation

◆ mc_lock

struct _starpu_spinlock _starpu_node::mc_lock

This per-node RW-locks protect mc_list and memchunk_cache entries

◆ mc_list

struct _starpu_mem_chunk_list _starpu_node::mc_list

Potentially in use memory chunks. The beginning of the list is clean (home node has a copy of the data, or the data is being transferred there), the remainder of the list may not be clean.

◆ mc_dirty_head

struct _starpu_mem_chunk* _starpu_node::mc_dirty_head

This is a shortcut inside the mc_list to the first potentially dirty MC. All MC before this are clean, MC before this only may be clean.

◆ mc_nb

unsigned _starpu_node::mc_nb

Number of elements in mc_list, number of elements in the clean part of mc_list plus the non-automatically allocated elements (which are thus always considered as clean)

◆ mc_clean_nb

unsigned _starpu_node::mc_clean_nb

◆ mc_cache

struct mc_cache_entry* _starpu_node::mc_cache

◆ mc_cache_nb

int _starpu_node::mc_cache_nb

◆ mc_cache_size

starpu_ssize_t _starpu_node::mc_cache_size

◆ tidying

unsigned _starpu_node::tidying

Whether some thread is currently tidying this node

◆ reclaiming

unsigned _starpu_node::reclaiming

Whether some thread is currently reclaiming memory for this node

◆ prefetch_out_of_memory

volatile int _starpu_node::prefetch_out_of_memory

This records that we tried to prefetch data but went out of memory, so will probably fail again to prefetch data, thus not trace each and every attempt.

◆ evictable

unsigned _starpu_node::evictable

Whether this memory node can evict data to another node

◆ data_requests

struct _starpu_data_request_prio_list _starpu_node::data_requests[STARPU_MAXNODES][2]

requests that have not been treated at all

◆ prefetch_requests

struct _starpu_data_request_prio_list _starpu_node::prefetch_requests[STARPU_MAXNODES][2]

◆ idle_requests

struct _starpu_data_request_prio_list _starpu_node::idle_requests[STARPU_MAXNODES][2]

◆ data_requests_list_mutex

starpu_pthread_mutex_t _starpu_node::data_requests_list_mutex[STARPU_MAXNODES][2]

◆ data_requests_pending

struct _starpu_data_request_prio_list _starpu_node::data_requests_pending[STARPU_MAXNODES][2]

requests that are not terminated (eg. async transfers)

◆ data_requests_npending

unsigned _starpu_node::data_requests_npending[STARPU_MAXNODES][2]

◆ data_requests_pending_list_mutex

starpu_pthread_mutex_t _starpu_node::data_requests_pending_list_mutex[STARPU_MAXNODES][2]

◆ malloc_on_node_default_flags

int _starpu_node::malloc_on_node_default_flags

◆ chunks

struct _starpu_chunk_list _starpu_node::chunks

One list of chunks per node

◆ nfreechunks

int _starpu_node::nfreechunks

Number of completely free chunks

◆ chunk_mutex

starpu_pthread_mutex_t _starpu_node::chunk_mutex

This protects chunks and nfreechunks

◆ global_size

size_t _starpu_node::global_size

◆ used_size

size_t _starpu_node::used_size

◆ waiting_size

size_t _starpu_node::waiting_size

◆ lock_nodes

starpu_pthread_mutex_t _starpu_node::lock_nodes

◆ cond_nodes

starpu_pthread_cond_t _starpu_node::cond_nodes

◆ padding

char _starpu_node::padding[STARPU_CACHELINE_SIZE]

Keep this last, to make sure to separate node data in separate cache lines.


The documentation for this struct was generated from the following file: