diff options
author | Ben Cheng <bccheng@google.com> | 2014-03-25 22:37:19 -0700 |
---|---|---|
committer | Ben Cheng <bccheng@google.com> | 2014-03-25 22:37:19 -0700 |
commit | 1bc5aee63eb72b341f506ad058502cd0361f0d10 (patch) | |
tree | c607e8252f3405424ff15bc2d00aa38dadbb2518 /gcc-4.9/libcilkrts/runtime/local_state.h | |
parent | 283a0bf58fcf333c58a2a92c3ebbc41fb9eb1fdb (diff) | |
download | toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.tar.gz toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.tar.bz2 toolchain_gcc-1bc5aee63eb72b341f506ad058502cd0361f0d10.zip |
Initial checkin of GCC 4.9.0 from trunk (r208799).
Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba
Diffstat (limited to 'gcc-4.9/libcilkrts/runtime/local_state.h')
-rw-r--r-- | gcc-4.9/libcilkrts/runtime/local_state.h | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/gcc-4.9/libcilkrts/runtime/local_state.h b/gcc-4.9/libcilkrts/runtime/local_state.h new file mode 100644 index 000000000..03f39897f --- /dev/null +++ b/gcc-4.9/libcilkrts/runtime/local_state.h @@ -0,0 +1,424 @@ +/* local_state.h -*-C++-*- + * + ************************************************************************* + * + * @copyright + * Copyright (C) 2009-2013, Intel Corporation + * All rights reserved. + * + * @copyright + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * @copyright + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + **************************************************************************/ + +/** + * @file local_state.h + * + * @brief The local_state structure contains additional OS-independent + * information that's associated with a worker, but doesn't need to be visible + * to the code generated by the compiler. + */ + +#ifndef INCLUDED_LOCAL_STATE_DOT_H +#define INCLUDED_LOCAL_STATE_DOT_H + +#include <internal/abi.h> +#include "worker_mutex.h" +#include "global_state.h" +#include "record-replay.h" +#include "signal_node.h" + +#include <setjmp.h> +#include <stddef.h> +#include <stdio.h> + + +#ifndef _WIN32 +# include <pthread.h> +#endif + +__CILKRTS_BEGIN_EXTERN_C + +/* Opaque types. */ + +struct full_frame; +struct free_list; +struct pending_exception_info; +/// Opaque type for replay entry. +typedef struct replay_entry_t replay_entry_t; + +/** + * @brief Magic numbers for local_state, used for debugging + */ +typedef unsigned long long ls_magic_t; + +/** + * @brief Scheduling stack function: A function that is decided on the program stack, + * but that must be executed on the scheduling stack. + */ +typedef void (*scheduling_stack_fcn_t) (__cilkrts_worker *w, + struct full_frame *ff, + __cilkrts_stack_frame *sf); + +/** + * @brief Type of this worker. + **/ +typedef enum cilk_worker_type +{ + WORKER_FREE, ///< Unused worker - available to be bound to user threads + WORKER_SYSTEM, ///< Worker created by runtime - able to steal from any worker + WORKER_USER ///< User thread - able to steal only from team members +} cilk_worker_type; + + +/** + * @brief The local_state structure contains additional OS-independent + * information that's associated with a worker, but doesn't need to be + * visible to the compiler. + * + * No compiler-generated code should need to know the layout of this + * structure. + * + * The fields of this struct can be classified as either local or + * shared. + * + * Local: This field is only accessed by the thread bound to this + * worker struct. Local fields can be freely accessed without + * acquiring locks. + * + * Shared: This field may be accessed by multiple worker threads. + * Accesses to shared fields usually requires locks, except in + * special situations where one can prove that locks are + * unnecessary. + * + * The fields of this can also be classified as "read-only" if the + * field does not change after it is initialized. Otherwise, the + * field is "read/write". Read-only fields do not require locks to + * access (ignoring the synchronization that might be needed for + * initialization if this can occur in parallel). + * + * Finally, we explicitly classify some fields as "synchronization" + * fields if they are used as part of a synchronization protocol in + * the runtime. These variables are generally shared and read/write. + * Mostly, this category includes lock variables and other variables + * that are involved in synchronization protocols (i.e., the THE + * protocol). + */ +struct local_state /* COMMON_PORTABLE */ +{ + /** This value should be in the first field in any local_state */ +# define WORKER_MAGIC_0 ((ls_magic_t)0xe0831a4a940c60b8ULL) + + /** + * Should be WORKER_MAGIC_0 or the local_state has been corrupted + * This magic field is shared because it is read on lock acquisitions. + * + * [shared read-only] + */ + ls_magic_t worker_magic_0; + + /** + * Mutex used to serialize access to the local_state + * Synchronization field. [shared read/write] + */ + struct mutex lock; + + /** + * Flag that indicates that the worker is interested in grabbing + * LOCK, and thus thieves should leave the worker alone. + * Written only by self, may be read by others. + * + * Synchronization field. [shared read/write] + */ + int do_not_steal; + + /** + * Lock that all thieves grab in order to compete for the right + * to disturb this worker. + * + * Synchronization field. [shared read/write] + */ + struct mutex steal_lock; + + /** + * Full frame that the worker is working on. + * + * While a worker w is executing, a thief may change + * w->l->frame_ff (on a successful steal) after acquiring w's + * lock. + * + * Unlocked accesses to w->l->frame_ff are safe (by w itself) when + * w's deque is empty, or when stealing from w has been disabled. + * + * [shared read/write] + */ + struct full_frame *frame_ff; + + /** + * Full frame that the worker will be working on next + * + * This field is normally local for a worker w. Another worker v + * may modify w->l->next_frame_ff, however, in the special case + * when v is returning a frame to a user thread w since w is the + * team leader. + * + * [shared read/write] + */ + struct full_frame *next_frame_ff; + + /** + * This is set iff this is a WORKER_USER and there has been a steal. It + * points to the first frame that was stolen since the team was last fully + * sync'd. Only this worker may continue past a sync in this function. + * + * This field is set by a thief for a victim that is a user + * thread, while holding the victim's lock. + * It can be cleared without a lock by the worker that will + * continue exuecting past the sync. + * + * [shared read/write] + */ + struct full_frame *last_full_frame; + + /** + * Team on which this worker is a participant. When a user worker enters, + * its team is its own worker struct and it can never change teams. When a + * system worker steals, it adopts the team of its victim. + * + * When a system worker w steals, it reads victim->l->team and + * joins this team. w->l->team is constant until the next time w + * returns control to the runtime. + * We must acquire the worker lock to change w->l->team. + * + * @note This field is 64-byte aligned because it is the first in + * the group of shared read-only fields. We want this group to + * fall on a different cache line from the previous group, which + * is shared read-write. + * + * [shared read-only] + */ + __attribute__((aligned(64))) + __cilkrts_worker *team; + + /** + * Type of this worker + * + * This field changes only when a worker binds or unbinds. + * Otherwise, the field is read-only while the worker is bound. + * + * [shared read-only] + */ + cilk_worker_type type; + + /** + * Lazy task queue of this worker - an array of pointers to stack frames. + * + * Read-only because deques are a fixed size in the current + * implementation. + * + * @note This field is 64-byte aligned because it is the first in + * the group of local fields. We want this group to fall on a + * different cache line from the previous group, which is shared + * read-only. + * + * [local read-only] + */ + __attribute__((aligned(64))) + __cilkrts_stack_frame **ltq; + + /** + * Pool of fibers waiting to be reused. + * [local read/write] + */ + cilk_fiber_pool fiber_pool; + + /** + * The fiber for the scheduling stacks. + * [local read/write] + */ + cilk_fiber* scheduling_fiber; + + /** + * Saved pointer to the leaf node in thread-local storage, when a + * user thread is imported. This pointer gets set to a + * meaningful value when binding a user thread, and cleared on + * unbind. + * + * [local read/write] + */ + __cilkrts_pedigree* original_pedigree_leaf; + + /** + * State of the random number generator + * + * [local read/write] + */ + unsigned rand_seed; + + /** + * Function to execute after transferring onto the scheduling stack. + * + * [local read/write] + */ + scheduling_stack_fcn_t post_suspend; + + /** + * __cilkrts_stack_frame we suspended when we transferred onto the + * scheduling stack. + * + * [local read/write] + */ + __cilkrts_stack_frame *suspended_stack; + + /** + * cilk_fiber that should be freed after returning from a + * spawn with a stolen parent or after stalling at a sync. + + * We calculate the stack to free when executing a reduction on + * the user stack, but we can not actually release the stack + * until control longjmps onto a runtime scheduling stack. + * + * This field is used to pass information to the runtime across + * the longjmp onto the scheduling stack. + * + * [local read/write] + */ + cilk_fiber* fiber_to_free; + + /** + * Saved exception object for an exception that is being passed to + * our parent + * + * [local read/write] + */ + struct pending_exception_info *pending_exception; + + /** + * Buckets for the memory allocator + * + * [local read/write] + */ + struct free_list *free_list[FRAME_MALLOC_NBUCKETS]; + + /** + * Potential function for the memory allocator + * + * [local read/write] + */ + size_t bucket_potential[FRAME_MALLOC_NBUCKETS]; + + /** + * Support for statistics + * + * Useful only when CILK_PROFIlE is compiled in. + * [local read/write] + */ + statistics* stats; + + /** + * Count indicates number of failures since last successful steal. This is + * used by the scheduler to reduce contention on shared flags. + * + * [local read/write] + */ + unsigned int steal_failure_count; + + /** + * 1 if work was stolen from another worker. When true, this will flag + * setup_for_execution_pedigree to increment the pedigree when we resume + * execution to match the increment that would have been done on a return + * from a spawn helper. + * + * [local read/write] + */ + int work_stolen; + + /** + * File pointer for record or replay + * Does FILE * work on Windows? + * During record, the file will be opened in write-only mode. + * During replay, the file will be opened in read-only mode. + * + * [local read/write] + */ + FILE *record_replay_fptr; + + /** + * Root of array of replay entries - NULL if we're not replaying a log + * + * [local read/write] + */ + replay_entry_t *replay_list_root; + + /** + * Current replay entry - NULL if we're not replaying a log + * + * [local read/write] + */ + replay_entry_t *replay_list_entry; + + /** + * Separate the signal_node from other things in the local_state by the + * sizeof a cache line for performance reasons. + * + * unused + */ + char buf[64]; + + /** + * Signal object for waking/sleeping the worker. This should be a pointer + * to avoid the possibility of caching problems. + * + * [shared read-only] + */ + signal_node_t *signal_node; + + /** This value should be in the last field in any local_state */ +# define WORKER_MAGIC_1 ((ls_magic_t)0x16164afb0ea0dff9ULL) + + /** + * Should be WORKER_MAGIC_1 or the local_state has been corrupted + * This magic field is shared because it is read on lock acquisitions. + * [shared read-only] + */ + ls_magic_t worker_magic_1; +}; + +/** + * Perform cleanup according to the function set before the longjmp(). + * + * Call this after longjmp() has completed and the worker is back on a + * scheduling stack. + * + * @param w __cilkrts_worker currently executing. + */ +void run_scheduling_stack_fcn(__cilkrts_worker *w); + +__CILKRTS_END_EXTERN_C + +#endif // ! defined(INCLUDED_LOCAL_STATE_DOT_H) |