void init()
{
op_attr['|'] = ATTRIBUTE(BINARY, ASSO_LEFT, PRI_1);
op_attr['&'] = ATTRIBUTE(BINARY, ASSO_LEFT, PRI_2);
op_attr['*'] = ATTRIBUTE(UNARY, ASSO_RIGHT, PRI_3);
op_attr['+'] = ATTRIBUTE(UNARY, ASSO_RIGHT, PRI_3);
op_attr['?'] = ATTRIBUTE(UNARY, ASSO_RIGHT, PRI_3);
}
void NetworkPriority::RegisterObject(Context* context)
{
context->RegisterFactory<NetworkPriority>();
ATTRIBUTE(NetworkPriority, VAR_FLOAT, "Base Priority", basePriority_, DEFAULT_BASE_PRIORITY, AM_DEFAULT);
ATTRIBUTE(NetworkPriority, VAR_FLOAT, "Distance Factor", distanceFactor_, DEFAULT_DISTANCE_FACTOR, AM_DEFAULT);
ATTRIBUTE(NetworkPriority, VAR_FLOAT, "Minimum Priority", minPriority_, DEFAULT_MIN_PRIORITY, AM_DEFAULT);
ATTRIBUTE(NetworkPriority, VAR_BOOL, "Always Update Owner", alwaysUpdateOwner_, true, AM_DEFAULT);
}
void CollisionShape::RegisterObject(Context* context)
{
context->RegisterFactory<CollisionShape>(PHYSICS_CATEGORY);
ACCESSOR_ATTRIBUTE(CollisionShape, VAR_BOOL, "Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
ENUM_ATTRIBUTE(CollisionShape, "Shape Type", shapeType_, typeNames, SHAPE_BOX, AM_DEFAULT);
ATTRIBUTE(CollisionShape, VAR_VECTOR3, "Size", size_, Vector3::ONE, AM_DEFAULT);
REF_ACCESSOR_ATTRIBUTE(CollisionShape, VAR_VECTOR3, "Offset Position", GetPosition, SetPosition, Vector3, Vector3::ZERO, AM_DEFAULT);
REF_ACCESSOR_ATTRIBUTE(CollisionShape, VAR_QUATERNION, "Offset Rotation", GetRotation, SetRotation, Quaternion, Quaternion::IDENTITY, AM_DEFAULT);
ACCESSOR_ATTRIBUTE(CollisionShape, VAR_RESOURCEREF, "Model", GetModelAttr, SetModelAttr, ResourceRef, ResourceRef(Model::GetTypeStatic()), AM_DEFAULT);
ATTRIBUTE(CollisionShape, VAR_INT, "LOD Level", lodLevel_, 0, AM_DEFAULT);
ATTRIBUTE(CollisionShape, VAR_FLOAT, "Collision Margin", margin_, DEFAULT_COLLISION_MARGIN, AM_DEFAULT);
ATTRIBUTE(CollisionShape, VAR_INT, "CustomGeometry NodeID", customGeometryID_, 0, AM_DEFAULT | AM_NODEID);
}
void Text::RegisterObject(Context* context)
{
context->RegisterFactory<Text>();
ACCESSOR_ATTRIBUTE(Text, VAR_RESOURCEREF, "Font", GetFontAttr, SetFontAttr, ResourceRef, ResourceRef(Font::GetTypeStatic()), AM_FILE);
ATTRIBUTE(Text, VAR_INT, "Font Size", fontSize_, DEFAULT_FONT_SIZE, AM_FILE);
ATTRIBUTE(Text, VAR_STRING, "Text", text_, String(), AM_FILE);
ENUM_ATTRIBUTE(Text, "Text Alignment", textAlignment_, horizontalAlignments, HA_LEFT, AM_FILE);
ATTRIBUTE(Text, VAR_FLOAT, "Row Spacing", rowSpacing_, 1.0f, AM_FILE);
ATTRIBUTE(Text, VAR_BOOL, "Word Wrap", wordWrap_, false, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Text, VAR_COLOR, "Selection Color", GetSelectionColor, SetSelectionColor, Color, Color::BLACK, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Text, VAR_COLOR, "Hover Color", GetHoverColor, SetHoverColor, Color, Color::BLACK, AM_FILE);
COPY_BASE_ATTRIBUTES(Text, UIElement);
}
bool AtomicSequence::Prepare(const PrepareMode mode) {
ATTRIBUTE("RotAngle" , m_alpha );
ATTRIBUTE("Inclination" , m_theta );
ATTRIBUTE("Azimut" , m_phi );
if (mode != PREP_UPDATE) m_type = MOD_ATOM;
if (mode != PREP_UPDATE) GetDuration();
bool tag = Sequence::Prepare(mode); //Prepare all pulses
CollectTPOIs(); //of the pulses
return tag;
}
void CubemapGenerator::RegisterObject(Context* context)
{
context->RegisterFactory<CubemapGenerator>();
ATTRIBUTE("Name Prefix", String, namePrefix_, "Cubemap", AM_DEFAULT);
ATTRIBUTE("Image Size", int, imageSize_, 512, AM_DEFAULT);
}
bool Module::Prepare (const PrepareMode mode){
ATTRIBUTE("Duration", m_duration);
//ATTRIBUTE("Observe" , NULL); //special case of observing attributes
return Prototype::Prepare(mode);
}
int MPIR_Reduce_intra_reduce_scatter_gather (
const void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
MPI_Op op,
int root,
MPIR_Comm *comm_ptr,
MPIR_Errflag_t *errflag )
{
int mpi_errno = MPI_SUCCESS;
int mpi_errno_ret = MPI_SUCCESS;
int comm_size, rank, type_size ATTRIBUTE((unused)), pof2, rem, newrank;
int mask, *cnts, *disps, i, j, send_idx=0;
int recv_idx, last_idx=0, newdst;
int dst, send_cnt, recv_cnt, newroot, newdst_tree_root, newroot_tree_root;
MPI_Aint true_lb, true_extent, extent;
void *tmp_buf;
MPIR_CHKLMEM_DECL(4);
comm_size = comm_ptr->local_size;
rank = comm_ptr->rank;
/* set op_errno to 0. stored in perthread structure */
{
MPIR_Per_thread_t *per_thread = NULL;
int err = 0;
MPID_THREADPRIV_KEY_GET_ADDR(MPIR_ThreadInfo.isThreaded, MPIR_Per_thread_key,
MPIR_Per_thread, per_thread, &err);
MPIR_Assert(err == 0);
per_thread->op_errno = 0;
}
/* Create a temporary buffer */
MPIR_Type_get_true_extent_impl(datatype, &true_lb, &true_extent);
MPIR_Datatype_get_extent_macro(datatype, extent);
/* I think this is the worse case, so we can avoid an assert()
* inside the for loop */
/* should be buf+{this}? */
MPIR_Ensure_Aint_fits_in_pointer(count * MPL_MAX(extent, true_extent));
MPIR_CHKLMEM_MALLOC(tmp_buf, void *, count*(MPL_MAX(extent,true_extent)),
mpi_errno, "temporary buffer", MPL_MEM_BUFFER);
/* adjust for potential negative lower bound in datatype */
tmp_buf = (void *)((char*)tmp_buf - true_lb);
/* If I'm not the root, then my recvbuf may not be valid, therefore
I have to allocate a temporary one */
if (rank != root) {
MPIR_CHKLMEM_MALLOC(recvbuf, void *,
count*(MPL_MAX(extent,true_extent)),
mpi_errno, "receive buffer", MPL_MEM_BUFFER);
recvbuf = (void *)((char*)recvbuf - true_lb);
}
void Text::RegisterObject(Context* context)
{
context->RegisterFactory<Text>(UI_CATEGORY);
COPY_BASE_ATTRIBUTES(Text, UIElement);
UPDATE_ATTRIBUTE_DEFAULT_VALUE(Text, "Use Derived Opacity", false);
ACCESSOR_ATTRIBUTE(Text, VAR_RESOURCEREF, "Font", GetFontAttr, SetFontAttr, ResourceRef, ResourceRef(Font::GetTypeStatic()), AM_FILE);
ATTRIBUTE(Text, VAR_INT, "Font Size", fontSize_, DEFAULT_FONT_SIZE, AM_FILE);
ATTRIBUTE(Text, VAR_STRING, "Text", text_, String::EMPTY, AM_FILE);
ENUM_ATTRIBUTE(Text, "Text Alignment", textAlignment_, horizontalAlignments, HA_LEFT, AM_FILE);
ATTRIBUTE(Text, VAR_FLOAT, "Row Spacing", rowSpacing_, 1.0f, AM_FILE);
ATTRIBUTE(Text, VAR_BOOL, "Word Wrap", wordWrap_, false, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Text, VAR_COLOR, "Selection Color", GetSelectionColor, SetSelectionColor, Color, Color::TRANSPARENT, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Text, VAR_COLOR, "Hover Color", GetHoverColor, SetHoverColor, Color, Color::TRANSPARENT, AM_FILE);
// Change the default value for UseDerivedOpacity
context->GetAttribute<Text>("Use Derived Opacity")->defaultValue_ = false;
}
bool ConcatSequence::Prepare (const PrepareMode mode){
m_type = MOD_CONCAT;
ATTRIBUTE("Repetitions", m_repetitions);
HIDDEN_ATTRIBUTE("Counter", m_counter);
if (mode != PREP_UPDATE) GetDuration();
if (mode != PREP_UPDATE)
SetRepCounter( 0);
return Sequence::Prepare(mode);
}
static int handler_recv_dequeue_complete(const ptl_event_t *e)
{
int mpi_errno = MPI_SUCCESS;
MPID_Request *const rreq = e->user_ptr;
int is_contig;
MPI_Aint last;
MPI_Aint dt_true_lb;
MPIDI_msg_sz_t data_sz;
MPID_Datatype *dt_ptr ATTRIBUTE((unused));
MPIDI_STATE_DECL(MPID_STATE_HANDLER_RECV_DEQUEUE_COMPLETE);
MPIDI_FUNC_ENTER(MPID_STATE_HANDLER_RECV_DEQUEUE_COMPLETE);
MPIU_Assert(e->type == PTL_EVENT_PUT || e->type == PTL_EVENT_PUT_OVERFLOW);
MPIDI_Datatype_get_info(rreq->dev.user_count, rreq->dev.datatype, is_contig, data_sz, dt_ptr, dt_true_lb);
dequeue_req(e);
if (e->type == PTL_EVENT_PUT_OVERFLOW) {
/* unpack the data from unexpected buffer */
MPIU_DBG_MSG_D(CH3_CHANNEL, VERBOSE, "is_contig = %d", is_contig);
if (is_contig) {
MPIU_Memcpy((char *)rreq->dev.user_buf + dt_true_lb, e->start, e->mlength);
} else {
last = e->mlength;
MPID_Segment_unpack(rreq->dev.segment_ptr, rreq->dev.segment_first, &last, e->start);
if (last != e->mlength)
MPIR_ERR_SET(rreq->status.MPI_ERROR, MPI_ERR_TYPE, "**dtypemismatch");
}
} else {
/* Data was placed directly into the user buffer, so datatype mismatch
is harder to detect. We use a simple check ensuring the received bytes
are a multiple of a single basic element. Currently, we do not detect
mismatches with datatypes constructed of more than one basic type */
MPI_Datatype dt_basic_type;
MPID_Datatype_get_basic_type(rreq->dev.datatype, dt_basic_type);
if (dt_basic_type != MPI_DATATYPE_NULL && (e->mlength % MPID_Datatype_get_basic_size(dt_basic_type)) != 0)
MPIR_ERR_SET(rreq->status.MPI_ERROR, MPI_ERR_TYPE, "**dtypemismatch");
}
mpi_errno = handler_recv_complete(e);
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_HANDLER_RECV_DEQUEUE_COMPLETE);
return mpi_errno;
fn_fail:
goto fn_exit;
}
static int MPIR_Reduce_binomial (
const void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
MPI_Op op,
int root,
MPID_Comm *comm_ptr,
int *errflag )
{
int mpi_errno = MPI_SUCCESS;
int mpi_errno_ret = MPI_SUCCESS;
MPI_Status status;
int comm_size, rank, is_commutative, type_size ATTRIBUTE((unused));
int mask, relrank, source, lroot;
MPI_Aint true_lb, true_extent, extent;
void *tmp_buf;
MPI_Comm comm;
MPIU_CHKLMEM_DECL(2);
if (count == 0) return MPI_SUCCESS;
comm = comm_ptr->handle;
comm_size = comm_ptr->local_size;
rank = comm_ptr->rank;
/* Create a temporary buffer */
MPIR_Type_get_true_extent_impl(datatype, &true_lb, &true_extent);
MPID_Datatype_get_extent_macro(datatype, extent);
is_commutative = MPIR_Op_is_commutative(op);
/* I think this is the worse case, so we can avoid an assert()
* inside the for loop */
/* should be buf+{this}? */
MPID_Ensure_Aint_fits_in_pointer(count * MPIR_MAX(extent, true_extent));
MPIU_CHKLMEM_MALLOC(tmp_buf, void *, count*(MPIR_MAX(extent,true_extent)),
mpi_errno, "temporary buffer");
/* adjust for potential negative lower bound in datatype */
tmp_buf = (void *)((char*)tmp_buf - true_lb);
/* If I'm not the root, then my recvbuf may not be valid, therefore
I have to allocate a temporary one */
if (rank != root) {
MPIU_CHKLMEM_MALLOC(recvbuf, void *,
count*(MPIR_MAX(extent,true_extent)),
mpi_errno, "receive buffer");
recvbuf = (void *)((char*)recvbuf - true_lb);
}
void settings_init() {
// recreate all strings -> move them to heap
for (int i = 0; i < LENGTH(g_settings); i++) {
if (g_settings[i].type == HS_String) {
g_settings[i].value.str = g_string_new(g_settings[i].value.s_init);
}
if (g_settings[i].type == HS_Int) {
g_settings[i].old_value_i = 1;
}
}
settings_find("monitors_locked")->value.i = g_initial_monitors_locked;
// create a settings object
g_settings_object = hsobject_create_and_link(hsobject_root(), "settings");
// ensure everything is nulled that is not explicitely initialized
HSAttribute* attributes = g_new0(HSAttribute, LENGTH(g_settings)+1);
HSAttribute last = ATTRIBUTE_LAST;
attributes[LENGTH(g_settings)] = last;
for (int i = 0; i < LENGTH(g_settings); i++) {
SettingsPair* sp = g_settings + i;
if (sp->type == HS_String) {
HSAttribute cur =
ATTRIBUTE(sp->name, sp->value.str, cb_on_change);
attributes[i] = cur;
} else if (sp->type == HS_Int) {
HSAttribute cur =
ATTRIBUTE(sp->name, sp->value.i, cb_on_change);
attributes[i] = cur;
} else if (sp->type == HS_Compatiblity) {
HSAttribute cur =
ATTRIBUTE_CUSTOM(sp->name, (HSAttributeCustom)cb_read_compat, cb_write_compat);
cur.data = sp;
attributes[i] = cur;
}
}
hsobject_set_attributes(g_settings_object, attributes);
g_free(attributes);
}
void Node::RegisterObject(Context* context)
{
context->RegisterFactory<Node>();
/// \todo When position/rotation updates are received from the network, route to SmoothedTransform if exists
REF_ACCESSOR_ATTRIBUTE(Node, VAR_STRING, "Name", GetName, SetName, String, String(), AM_DEFAULT);
REF_ACCESSOR_ATTRIBUTE(Node, VAR_VECTOR3, "Position", GetPosition, SetPosition, Vector3, Vector3::ZERO, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Node, VAR_QUATERNION, "Rotation", GetRotation, SetRotation, Quaternion, Quaternion::IDENTITY, AM_FILE);
REF_ACCESSOR_ATTRIBUTE(Node, VAR_VECTOR3, "Scale", GetScale, SetScale, Vector3, Vector3::ONE, AM_DEFAULT);
ATTRIBUTE(Node, VAR_VARIANTMAP, "Variables", vars_, VariantMap(), AM_FILE); // Network replication of vars uses custom data
REF_ACCESSOR_ATTRIBUTE(Node, VAR_VECTOR3, "Network Position", GetNetPositionAttr, SetNetPositionAttr, Vector3, Vector3::ZERO, AM_NET | AM_LATESTDATA | AM_NOEDIT);
REF_ACCESSOR_ATTRIBUTE(Node, VAR_BUFFER, "Network Rotation", GetNetRotationAttr, SetNetRotationAttr, PODVector<unsigned char>, PODVector<unsigned char>(), AM_NET | AM_LATESTDATA | AM_NOEDIT);
REF_ACCESSOR_ATTRIBUTE(Node, VAR_BUFFER, "Network Parent Node", GetNetParentAttr, SetNetParentAttr, PODVector<unsigned char>, PODVector<unsigned char>(), AM_NET | AM_NOEDIT);
}
void CollisionShape::RegisterObject(Context* context)
{
context->RegisterFactory<CollisionShape>(PHYSICS_CATEGORY);
ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
ENUM_ATTRIBUTE("Shape Type", shapeType_, typeNames, SHAPE_BOX, AM_DEFAULT);
ATTRIBUTE("Size", Vector3, size_, Vector3::ONE, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Offset Position", GetPosition, SetPosition, Vector3, Vector3::ZERO, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Offset Rotation", GetRotation, SetRotation, Quaternion, Quaternion::IDENTITY, AM_DEFAULT);
MIXED_ACCESSOR_ATTRIBUTE("Model", GetModelAttr, SetModelAttr, ResourceRef, ResourceRef(Model::GetTypeStatic()), AM_DEFAULT);
ATTRIBUTE("LOD Level", int, lodLevel_, 0, AM_DEFAULT);
ATTRIBUTE("Collision Margin", float, margin_, DEFAULT_COLLISION_MARGIN, AM_DEFAULT);
ATTRIBUTE("CustomGeometry NodeID", int, customGeometryID_, 0, AM_DEFAULT | AM_NODEID);
}
/*
* You must configure MPICH2 with the logging option enabled (--enable-g=log)
* for these routines to print - in which case, they use the same options
* as the logging code, including print to file and control by class (DATATYPE)
*/
void MPIDU_Datatype_debug(MPI_Datatype type,
int array_ct)
{
int is_builtin;
MPIDU_Datatype *dtp ATTRIBUTE((unused));
is_builtin = (HANDLE_GET_KIND(type) == HANDLE_KIND_BUILTIN);
/* can get a NULL type a number of different ways, including not having
* fortran support included.
*/
if (type == MPI_DATATYPE_NULL) {
MPL_DBG_OUT_FMT(MPIR_DBG_DATATYPE,
(MPL_DBG_FDEST,
"# MPIU_Datatype_debug: MPI_Datatype = MPI_DATATYPE_NULL"));
return;
}
MPL_DBG_OUT_FMT(MPIR_DBG_DATATYPE,(MPL_DBG_FDEST,
"# MPIU_Datatype_debug: MPI_Datatype = 0x%0x (%s)", type,
(is_builtin) ? MPIDU_Datatype_builtin_to_string(type) :
"derived"));
if (is_builtin) return;
MPIDU_Datatype_get_ptr(type, dtp);
MPIR_Assert(dtp != NULL);
MPL_DBG_OUT_FMT(MPIR_DBG_DATATYPE,(MPL_DBG_FDEST,
"# Size = " MPI_AINT_FMT_DEC_SPEC ", Extent = " MPI_AINT_FMT_DEC_SPEC ", LB = " MPI_AINT_FMT_DEC_SPEC "%s, UB = " MPI_AINT_FMT_DEC_SPEC "%s, Extent = " MPI_AINT_FMT_DEC_SPEC ", Element Size = " MPI_AINT_FMT_DEC_SPEC " (%s), %s",
(MPI_Aint) dtp->size,
(MPI_Aint) dtp->extent,
(MPI_Aint) dtp->lb,
(dtp->has_sticky_lb) ? "(sticky)" : "",
(MPI_Aint) dtp->ub,
(dtp->has_sticky_ub) ? "(sticky)" : "",
(MPI_Aint) dtp->extent,
(MPI_Aint) dtp->builtin_element_size,
dtp->builtin_element_size == -1 ? "multiple types" :
MPIDU_Datatype_builtin_to_string(dtp->basic_type),
dtp->is_contig ? "is N contig" : "is not N contig"));
MPL_DBG_OUT(MPIR_DBG_DATATYPE,"# Contents:");
MPIDI_Datatype_contents_printf(type, 0, array_ct);
MPL_DBG_OUT(MPIR_DBG_DATATYPE,"# Dataloop:");
MPIDI_Datatype_dot_printf(type, 0, 1);
}
void Vehicle::RegisterObject(Context* context)
{
context->RegisterFactory<Vehicle>();
ATTRIBUTE(Vehicle, VAR_FLOAT, "Controls Yaw", controls_.yaw_, 0.0f, AM_DEFAULT);
ATTRIBUTE(Vehicle, VAR_FLOAT, "Controls Pitch", controls_.pitch_, 0.0f, AM_DEFAULT);
ATTRIBUTE(Vehicle, VAR_FLOAT, "Steering", steering_, 0.0f, AM_DEFAULT);
// Register wheel node IDs as attributes so that the wheel nodes can be reaquired on deserialization. They need to be tagged
// as node ID's so that the deserialization code knows to rewrite the IDs in case they are different on load than on save
ATTRIBUTE(Vehicle, VAR_INT, "Front Left Node", frontLeftID_, 0, AM_DEFAULT | AM_NODEID);
ATTRIBUTE(Vehicle, VAR_INT, "Front Right Node", frontRightID_, 0, AM_DEFAULT | AM_NODEID);
ATTRIBUTE(Vehicle, VAR_INT, "Rear Left Node", rearLeftID_, 0, AM_DEFAULT | AM_NODEID);
ATTRIBUTE(Vehicle, VAR_INT, "Rear Right Node", rearRightID_, 0, AM_DEFAULT | AM_NODEID);
}
int MPIDI_CH3I_RMA_Cleanup_ops_aggressive(MPIR_Win * win_ptr)
{
int i, local_completed = 0, remote_completed ATTRIBUTE((unused)) = 0;
int mpi_errno = MPI_SUCCESS;
MPIDI_RMA_Target_t *curr_target = NULL;
int made_progress = 0;
/* find the first target that has something to issue */
for (i = 0; i < win_ptr->num_slots; i++) {
if (win_ptr->slots[i].target_list_head != NULL) {
curr_target = win_ptr->slots[i].target_list_head;
while (curr_target != NULL && curr_target->pending_net_ops_list_head == NULL &&
curr_target->pending_user_ops_list_head == NULL)
curr_target = curr_target->next;
if (curr_target != NULL)
break;
}
}
if (curr_target == NULL)
goto fn_exit;
if (curr_target->sync.sync_flag < MPIDI_RMA_SYNC_FLUSH_LOCAL)
curr_target->sync.sync_flag = MPIDI_RMA_SYNC_FLUSH_LOCAL;
/* Issue out all operations. */
mpi_errno = MPIDI_CH3I_RMA_Make_progress_target(win_ptr, curr_target->target_rank,
&made_progress);
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
/* Wait for local completion. */
do {
MPIDI_CH3I_RMA_ops_completion(win_ptr, curr_target, local_completed, remote_completed);
if (!local_completed) {
mpi_errno = wait_progress_engine();
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
}
} while (!local_completed);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
bool TriangleGradPulse::Prepare (const PrepareMode mode) {
bool btag = true;
ATTRIBUTE("Amplitude", m_amplitude );
UNOBSERVABLE_ATTRIBUTE("TriangleType");
if ( mode != PREP_UPDATE) {
if (!HasDOMattribute("Duration") ) {
m_duration = ( fabs(m_amplitude)>0.0 ? fabs(m_amplitude)/m_slew_rate : 1e-5 );
} else {
if (m_duration < (m_amplitude/m_slew_rate) && mode == PREP_VERBOSE)
cout << "Warning in in TRIANGLEGRADPULSE " << GetName()
<< "duration too short (slew-rate conflict)" << endl;
}
}
SetArea( 0.5*m_amplitude*GetDuration() );
btag = ( GradPulse::Prepare(mode) && btag );
if ( mode != PREP_UPDATE) {
if (HasDOMattribute("TriangleType") ) {
string type = GetDOMattribute("TriangleType");
if (type == "UP") m_triangle_type = TRIANGLE_UP;
if (type == "DN") m_triangle_type = TRIANGLE_DN;
} else {
AddDOMattribute("TriangleType","UP");
}
}
if (!btag && mode == PREP_VERBOSE)
cout << "\n warning in Prepare(1) of TRAPGRADPULSE " << GetName() << endl;
if (mode != PREP_UPDATE) {
HideAttribute("Area" );
HideAttribute("MaxAmpl", false);
HideAttribute("SlewRate", false);
}
return btag;
}
void Constraint::RegisterObject(Context* context)
{
context->RegisterFactory<Constraint>();
ENUM_ATTRIBUTE(Constraint, "Constraint Type", constraintType_, typeNames, CONSTRAINT_NONE, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_VECTOR3, "Position", position_, Vector3::ZERO, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_QUATERNION, "Rotation", rotation_, Quaternion::IDENTITY, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_VECTOR3, "Other Body Position", otherPosition_, Vector3::ZERO, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_QUATERNION, "Other Body Rotation", otherRotation_, Quaternion::IDENTITY, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_INT, "Other Body NodeID", otherBodyNodeID_, 0, AM_DEFAULT | AM_NODEID);
REF_ACCESSOR_ATTRIBUTE(Constraint, VAR_VECTOR2, "High Limit", GetHighLimit, SetHighLimit, Vector2, Vector2::ZERO, AM_DEFAULT);
REF_ACCESSOR_ATTRIBUTE(Constraint, VAR_VECTOR2, "Low Limit", GetLowLimit, SetLowLimit, Vector2, Vector2::ZERO, AM_DEFAULT);
ATTRIBUTE(Constraint, VAR_BOOL, "Disable Collision", disableCollision_, false, AM_DEFAULT);
}
/* This function implements a binomial tree reduce.
Cost = lgp.alpha + n.lgp.beta + n.lgp.gamma
*/
int MPIR_Reduce_intra_binomial(const void *sendbuf,
void *recvbuf,
int count,
MPI_Datatype datatype,
MPI_Op op, int root, MPIR_Comm * comm_ptr, MPIR_Errflag_t * errflag)
{
int mpi_errno = MPI_SUCCESS;
int mpi_errno_ret = MPI_SUCCESS;
MPI_Status status;
int comm_size, rank, is_commutative, type_size ATTRIBUTE((unused));
int mask, relrank, source, lroot;
MPI_Aint true_lb, true_extent, extent;
void *tmp_buf;
MPIR_CHKLMEM_DECL(2);
if (count == 0)
return MPI_SUCCESS;
comm_size = comm_ptr->local_size;
rank = comm_ptr->rank;
/* Create a temporary buffer */
MPIR_Type_get_true_extent_impl(datatype, &true_lb, &true_extent);
MPIR_Datatype_get_extent_macro(datatype, extent);
is_commutative = MPIR_Op_is_commutative(op);
MPIR_CHKLMEM_MALLOC(tmp_buf, void *, count * (MPL_MAX(extent, true_extent)),
mpi_errno, "temporary buffer", MPL_MEM_BUFFER);
/* adjust for potential negative lower bound in datatype */
tmp_buf = (void *) ((char *) tmp_buf - true_lb);
/* If I'm not the root, then my recvbuf may not be valid, therefore
* I have to allocate a temporary one */
if (rank != root) {
MPIR_CHKLMEM_MALLOC(recvbuf, void *,
count * (MPL_MAX(extent, true_extent)),
mpi_errno, "receive buffer", MPL_MEM_BUFFER);
recvbuf = (void *) ((char *) recvbuf - true_lb);
}
void Light::RegisterObject(Context* context)
{
context->RegisterFactory<Light>(SCENE_CATEGORY);
ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
ENUM_ACCESSOR_ATTRIBUTE("Light Type", GetLightType, SetLightType, LightType, typeNames, DEFAULT_LIGHTTYPE, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Color", GetColor, SetColor, Color, Color::WHITE, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Specular Intensity", GetSpecularIntensity, SetSpecularIntensity, float, DEFAULT_SPECULARINTENSITY,
AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Brightness Multiplier", GetBrightness, SetBrightness, float, DEFAULT_BRIGHTNESS, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Range", GetRange, SetRange, float, DEFAULT_RANGE, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Spot FOV", GetFov, SetFov, float, DEFAULT_LIGHT_FOV, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Spot Aspect Ratio", GetAspectRatio, SetAspectRatio, float, 1.0f, AM_DEFAULT);
MIXED_ACCESSOR_ATTRIBUTE("Attenuation Texture", GetRampTextureAttr, SetRampTextureAttr, ResourceRef,
ResourceRef(Texture2D::GetTypeStatic()), AM_DEFAULT);
MIXED_ACCESSOR_ATTRIBUTE("Light Shape Texture", GetShapeTextureAttr, SetShapeTextureAttr, ResourceRef,
ResourceRef(Texture2D::GetTypeStatic()), AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
ATTRIBUTE("Per Vertex", bool, perVertex_, false, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Fade Distance", GetFadeDistance, SetFadeDistance, float, 0.0f, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Shadow Fade Distance", GetShadowFadeDistance, SetShadowFadeDistance, float, 0.0f, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Shadow Intensity", GetShadowIntensity, SetShadowIntensity, float, 0.0f, AM_DEFAULT);
ACCESSOR_ATTRIBUTE("Shadow Resolution", GetShadowResolution, SetShadowResolution, float, 1.0f, AM_DEFAULT);
ATTRIBUTE("Focus To Scene", bool, shadowFocus_.focus_, true, AM_DEFAULT);
ATTRIBUTE("Non-uniform View", bool, shadowFocus_.nonUniform_, true, AM_DEFAULT);
ATTRIBUTE("Auto-Reduce Size", bool, shadowFocus_.autoSize_, true, AM_DEFAULT);
ATTRIBUTE("CSM Splits", Vector4, shadowCascade_.splits_, Vector4(DEFAULT_SHADOWSPLIT, 0.0f, 0.0f, 0.0f), AM_DEFAULT);
ATTRIBUTE("CSM Fade Start", float, shadowCascade_.fadeStart_, DEFAULT_SHADOWFADESTART, AM_DEFAULT);
ATTRIBUTE("CSM Bias Auto Adjust", float, shadowCascade_.biasAutoAdjust_, DEFAULT_BIASAUTOADJUST, AM_DEFAULT);
ATTRIBUTE("View Size Quantize", float, shadowFocus_.quantize_, DEFAULT_SHADOWQUANTIZE, AM_DEFAULT);
ATTRIBUTE("View Size Minimum", float, shadowFocus_.minView_, DEFAULT_SHADOWMINVIEW, AM_DEFAULT);
ATTRIBUTE("Depth Constant Bias", float, shadowBias_.constantBias_, DEFAULT_CONSTANTBIAS, AM_DEFAULT);
ATTRIBUTE("Depth Slope Bias", float, shadowBias_.slopeScaledBias_, DEFAULT_SLOPESCALEDBIAS, AM_DEFAULT);
ATTRIBUTE("Near/Farclip Ratio", float, shadowNearFarRatio_, DEFAULT_SHADOWNEARFARRATIO, AM_DEFAULT);
ATTRIBUTE("View Mask", int, viewMask_, DEFAULT_VIEWMASK, AM_DEFAULT);
ATTRIBUTE("Light Mask", int, lightMask_, DEFAULT_LIGHTMASK, AM_DEFAULT);
}
int MPIDO_Gatherv(const void *sendbuf,
int sendcount,
MPI_Datatype sendtype,
void *recvbuf,
const int *recvcounts,
const int *displs,
MPI_Datatype recvtype,
int root,
MPID_Comm * comm_ptr,
int *mpierrno)
{
#ifndef HAVE_PAMI_IN_PLACE
if (sendbuf == MPI_IN_PLACE)
{
MPID_Abort (NULL, 0, 1, "'MPI_IN_PLACE' requries support for `PAMI_IN_PLACE`");
return -1;
}
#endif
TRACE_ERR("Entering MPIDO_Gatherv\n");
int i;
int contig ATTRIBUTE((unused)), rsize ATTRIBUTE((unused)), ssize ATTRIBUTE((unused));
int pamidt = 1;
MPID_Datatype *dt_ptr = NULL;
MPI_Aint send_true_lb, recv_true_lb;
char *sbuf, *rbuf;
pami_type_t stype, rtype;
int tmp;
volatile unsigned gatherv_active = 1;
const int rank = comm_ptr->rank;
const int size = comm_ptr->local_size;
#if ASSERT_LEVEL==0
/* We can't afford the tracing in ndebug/performance libraries */
const unsigned verbose = 0;
#else
const unsigned verbose = (MPIDI_Process.verbose >= MPIDI_VERBOSE_DETAILS_ALL) && (rank == 0);
#endif
const struct MPIDI_Comm* const mpid = &(comm_ptr->mpid);
const int selected_type = mpid->user_selected_type[PAMI_XFER_GATHERV_INT];
/* Check for native PAMI types and MPI_IN_PLACE on sendbuf */
/* MPI_IN_PLACE is a nonlocal decision. We will need a preallreduce if we ever have
* multiple "good" gathervs that work on different counts for example */
if((sendbuf != MPI_IN_PLACE) && (MPIDI_Datatype_to_pami(sendtype, &stype, -1, NULL, &tmp) != MPI_SUCCESS))
pamidt = 0;
if(MPIDI_Datatype_to_pami(recvtype, &rtype, -1, NULL, &tmp) != MPI_SUCCESS)
pamidt = 0;
if(pamidt == 0 || selected_type == MPID_COLL_USE_MPICH)
{
if(unlikely(verbose))
fprintf(stderr,"Using MPICH gatherv algorithm\n");
TRACE_ERR("GATHERV using MPICH\n");
MPIDI_Update_last_algorithm(comm_ptr, "GATHERV_MPICH");
#if CUDA_AWARE_SUPPORT
if(MPIDI_Process.cuda_aware_support_on)
{
MPI_Aint sdt_extent,rdt_extent;
MPID_Datatype_get_extent_macro(sendtype, sdt_extent);
MPID_Datatype_get_extent_macro(recvtype, rdt_extent);
char *scbuf = NULL;
char *rcbuf = NULL;
int is_send_dev_buf = MPIDI_cuda_is_device_buf(sendbuf);
int is_recv_dev_buf = (rank == root) ? MPIDI_cuda_is_device_buf(recvbuf) : 0;
if(is_send_dev_buf)
{
scbuf = MPL_malloc(sdt_extent * sendcount);
cudaError_t cudaerr = CudaMemcpy(scbuf, sendbuf, sdt_extent * sendcount, cudaMemcpyDeviceToHost);
if (cudaSuccess != cudaerr)
fprintf(stderr, "cudaMemcpy failed: %s\n", CudaGetErrorString(cudaerr));
}
else
scbuf = sendbuf;
size_t rtotal_buf;
if(is_recv_dev_buf)
{
//Since displs can be non-continous, we need to calculate max buffer size
int highest_displs = displs[size - 1];
int highest_recvcount = recvcounts[size - 1];
for(i = 0; i < size; i++)
{
if(displs[i]+recvcounts[i] > highest_displs+highest_recvcount)
{
highest_displs = displs[i];
highest_recvcount = recvcounts[i];
}
}
rtotal_buf = (highest_displs+highest_recvcount)*rdt_extent;
rcbuf = MPL_malloc(rtotal_buf);
if(sendbuf == MPI_IN_PLACE)
{
cudaError_t cudaerr = CudaMemcpy(rcbuf, recvbuf, rtotal_buf, cudaMemcpyDeviceToHost);
if (cudaSuccess != cudaerr)
fprintf(stderr, "cudaMemcpy failed: %s\n", CudaGetErrorString(cudaerr));
}
else
memset(rcbuf, 0, rtotal_buf);
}
else
rcbuf = recvbuf;
int cuda_res = MPIR_Gatherv(scbuf, sendcount, sendtype, rcbuf, recvcounts, displs, recvtype, root, comm_ptr, mpierrno);
if(is_send_dev_buf)MPL_free(scbuf);
if(is_recv_dev_buf)
{
cudaError_t cudaerr = CudaMemcpy(recvbuf, rcbuf, rtotal_buf, cudaMemcpyHostToDevice);
if (cudaSuccess != cudaerr)
fprintf(stderr, "cudaMemcpy failed: %s\n", CudaGetErrorString(cudaerr));
MPL_free(rcbuf);
}
return cuda_res;
}
else
#endif
return MPIR_Gatherv(sendbuf, sendcount, sendtype,
recvbuf, recvcounts, displs, recvtype,
root, comm_ptr, mpierrno);
}
MPIDI_Datatype_get_info(1, recvtype, contig, rsize, dt_ptr, recv_true_lb);
rbuf = (char *)recvbuf + recv_true_lb;
sbuf = (void *) sendbuf;
pami_xfer_t gatherv;
gatherv.cb_done = cb_gatherv;
gatherv.cookie = (void *)&gatherv_active;
gatherv.cmd.xfer_gatherv_int.root = MPIDI_Task_to_endpoint(MPID_VCR_GET_LPID(comm_ptr->vcr, root), 0);
gatherv.cmd.xfer_gatherv_int.rcvbuf = rbuf;
gatherv.cmd.xfer_gatherv_int.rtype = rtype;
gatherv.cmd.xfer_gatherv_int.rtypecounts = (int *) recvcounts;
gatherv.cmd.xfer_gatherv_int.rdispls = (int *) displs;
gatherv.cmd.xfer_gatherv_int.sndbuf = NULL;
gatherv.cmd.xfer_gatherv_int.stype = stype;
gatherv.cmd.xfer_gatherv_int.stypecount = sendcount;
if(rank == root)
{
if(sendbuf == MPI_IN_PLACE)
{
if(unlikely(verbose))
fprintf(stderr,"gatherv MPI_IN_PLACE buffering\n");
sbuf = PAMI_IN_PLACE;
gatherv.cmd.xfer_gatherv_int.stype = rtype;
gatherv.cmd.xfer_gatherv_int.stypecount = recvcounts[rank];
}
else
{
MPIDI_Datatype_get_info(1, sendtype, contig, ssize, dt_ptr, send_true_lb);
sbuf = (char *)sbuf + send_true_lb;
}
}
gatherv.cmd.xfer_gatherv_int.sndbuf = sbuf;
pami_algorithm_t my_gatherv;
const pami_metadata_t *my_md = (pami_metadata_t *)NULL;
int queryreq = 0;
if(selected_type == MPID_COLL_OPTIMIZED)
{
TRACE_ERR("Optimized gatherv %s was selected\n",
mpid->opt_protocol_md[PAMI_XFER_GATHERV_INT][0].name);
my_gatherv = mpid->opt_protocol[PAMI_XFER_GATHERV_INT][0];
my_md = &mpid->opt_protocol_md[PAMI_XFER_GATHERV_INT][0];
queryreq = mpid->must_query[PAMI_XFER_GATHERV_INT][0];
}
else
{
TRACE_ERR("Optimized gatherv %s was set by user\n",
mpid->user_metadata[PAMI_XFER_GATHERV_INT].name);
my_gatherv = mpid->user_selected[PAMI_XFER_GATHERV_INT];
my_md = &mpid->user_metadata[PAMI_XFER_GATHERV_INT];
queryreq = selected_type;
}
gatherv.algorithm = my_gatherv;
if(unlikely(queryreq == MPID_COLL_ALWAYS_QUERY ||
queryreq == MPID_COLL_CHECK_FN_REQUIRED))
{
metadata_result_t result = {0};
TRACE_ERR("querying gatherv protocol %s, type was %d\n",
my_md->name, queryreq);
if(my_md->check_fn == NULL)
{
/* process metadata bits */
if((!my_md->check_correct.values.inplace) && (sendbuf == MPI_IN_PLACE))
result.check.unspecified = 1;
/* Can't check ranges like this. Non-local. Comment out for now.
if(my_md->check_correct.values.rangeminmax)
{
MPI_Aint data_true_lb;
MPID_Datatype *data_ptr;
int data_size, data_contig;
MPIDI_Datatype_get_info(sendcount, sendtype, data_contig, data_size, data_ptr, data_true_lb);
if((my_md->range_lo <= data_size) &&
(my_md->range_hi >= data_size))
;
else
{
result.check.range = 1;
if(unlikely(verbose))
{
fprintf(stderr,"message size (%u) outside range (%zu<->%zu) for %s.\n",
data_size,
my_md->range_lo,
my_md->range_hi,
my_md->name);
}
}
}
*/
}
else /* calling the check fn is sufficient */
result = my_md->check_fn(&gatherv);
TRACE_ERR("bitmask: %#X\n", result.bitmask);
result.check.nonlocal = 0; /* #warning REMOVE THIS WHEN IMPLEMENTED */
if(result.bitmask)
{
if(unlikely(verbose))
fprintf(stderr,"Query failed for %s. Using MPICH gatherv.\n", my_md->name);
MPIDI_Update_last_algorithm(comm_ptr, "GATHERV_MPICH");
return MPIR_Gatherv(sendbuf, sendcount, sendtype,
recvbuf, recvcounts, displs, recvtype,
root, comm_ptr, mpierrno);
}
if(my_md->check_correct.values.asyncflowctl && !(--(comm_ptr->mpid.num_requests)))
{
comm_ptr->mpid.num_requests = MPIDI_Process.optimized.num_requests;
int tmpmpierrno;
if(unlikely(verbose))
fprintf(stderr,"Query barrier required for %s\n", my_md->name);
MPIDO_Barrier(comm_ptr, &tmpmpierrno);
}
}
MPIDI_Update_last_algorithm(comm_ptr, my_md->name);
if(unlikely(verbose))
{
unsigned long long int threadID;
MPL_thread_id_t tid;
MPL_thread_self(&tid);
threadID = (unsigned long long int)tid;
fprintf(stderr,"<%llx> Using protocol %s for gatherv on %u\n",
threadID,
my_md->name,
(unsigned) comm_ptr->context_id);
}
MPIDI_Post_coll_t gatherv_post;
MPIDI_Context_post(MPIDI_Context[0], &gatherv_post.state,
MPIDI_Pami_post_wrapper, (void *)&gatherv);
TRACE_ERR("Waiting on active %d\n", gatherv_active);
MPID_PROGRESS_WAIT_WHILE(gatherv_active);
TRACE_ERR("Leaving MPIDO_Gatherv\n");
return 0;
}
else {
mpi_errno = reqFn( vc, sreq, complete );
}
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3U_HANDLE_SEND_REQ);
return mpi_errno;
}
/* ----------------------------------------------------------------------- */
/* Here are the functions that implement the actions that are taken when
* data is available for a send request (or other completion operations)
* These include "send" requests that are part of the RMA implementation.
*/
/* ----------------------------------------------------------------------- */
int MPIDI_CH3_ReqHandler_GetSendRespComplete( MPIDI_VC_t *vc ATTRIBUTE((unused)),
MPID_Request *sreq,
int *complete )
{
int mpi_errno = MPI_SUCCESS;
MPID_Win *win_ptr;
MPID_Win_get_ptr(sreq->dev.target_win_handle, win_ptr);
mpi_errno = MPIDI_CH3_Finish_rma_op_target(NULL, win_ptr, FALSE, sreq->dev.flags, MPI_WIN_NULL);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
/* mark data transfer as complete and decrement CC */
MPIDI_CH3U_Request_complete(sreq);
*complete = TRUE;
bool ExternalGradPulse::Prepare (const PrepareMode mode) {
ATTRIBUTE("Filename", m_fname);
ATTRIBUTE("Scale" , m_scale);
ATTRIBUTE("DataPath", m_dpath);
bool btag = GradPulse::Prepare(mode);
if (!m_dpath.length())
m_dpath = "/";
if (!m_fname.length()) {
cout << "\n warning in Prepare(1) of ExternalGradPulse " << GetName()
<< " : can not read binary file with empty name" << endl;
return false;
}
BinaryContext bc (m_fname, IO::IN);
NDData<double> data;
if (bc.Status() != IO::OK) {
cout << "\n warning in Prepare(1) of ExternalGradPulse " << GetName()
<< " : can not read binary file " << m_fname << endl;
return false;
}
m_dname = "G";
if (m_axis == AXIS_GX)
m_dname += "x";
else if (m_axis == AXIS_GY)
m_dname += "y";
else if (m_axis == AXIS_GZ)
m_dname += "z";
if (bc.Read(data, m_dname, m_dpath) != IO::OK) {
printf ("Couldn't read %s from file %s\n", URI(m_dpath, m_dname).c_str(), m_fname.c_str());
return false;
}
m_magnitudes = data.Data();
if (bc.Read(data, "times", m_dpath) != IO::OK) {
printf ("Couldn't read timing data %s \n", URI(m_dpath, "times").c_str());
return false;
}
m_times = data.Data();
if (m_magnitudes.size() != m_times.size()) {
cout << "\n warning in Prepare(1) of ExternalGradPulse " << GetName()
<< " : # of magnitude samples and time points must agree ("
<< m_magnitudes.size() << " != " << m_times.size() << ")" << endl;
return false;
}
m_duration = m_times.back();
if ( btag && m_tpoi.GetSize()>0 )
m_area = GetAreaNumeric(m_tpoi.GetSize());
btag = ( GradPulse::Prepare(mode) && btag);
if (mode != PREP_UPDATE) {
HideAttribute ("Duration");
HideAttribute ("Area");
HideAttribute ("MaxAmpl",false);
HideAttribute ("SlewRate",false);
}
if (!btag && mode == PREP_VERBOSE)
cout << "\n warning in Prepare(1) of ExternalGradPulse " << GetName()
<< " : can not read binary file " << m_fname << endl;
return btag;
}
static int _mxm_handle_rreq(MPID_Request * req)
{
int complete = FALSE, found = FALSE;
int dt_contig;
MPI_Aint dt_true_lb ATTRIBUTE((unused));
MPIDI_msg_sz_t userbuf_sz;
MPID_Datatype *dt_ptr;
MPIDI_msg_sz_t data_sz;
MPID_nem_mxm_vc_area *vc_area ATTRIBUTE((unused)) = NULL;
MPID_nem_mxm_req_area *req_area = NULL;
void *tmp_buf = NULL;
MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_MSGQ_MUTEX);
found = MPIDI_CH3U_Recvq_DP(req);
MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_MSGQ_MUTEX);
/* an MPI_ANY_SOURCE request may have been previously removed from the
* CH3 queue by an FDP (find and dequeue posted) operation */
if (req->dev.match.parts.rank != MPI_ANY_SOURCE) {
MPIU_Assert(found);
}
MPIDI_Datatype_get_info(req->dev.user_count, req->dev.datatype, dt_contig, userbuf_sz, dt_ptr,
dt_true_lb);
vc_area = VC_BASE(req->ch.vc);
req_area = REQ_BASE(req);
_dbg_mxm_out_buf(req_area->iov_buf[0].ptr,
(req_area->iov_buf[0].length > 16 ? 16 : req_area->iov_buf[0].length));
if (req->dev.recv_data_sz <= userbuf_sz) {
data_sz = req->dev.recv_data_sz;
if (req->status.MPI_ERROR == MPI_ERR_TRUNCATE) {
req->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_TRUNCATE, "**truncate",
"**truncate %d %d %d %d",
req->status.MPI_SOURCE,
req->status.MPI_TAG, req->dev.recv_data_sz,
userbuf_sz);
}
}
else {
data_sz = userbuf_sz;
MPIR_STATUS_SET_COUNT(req->status, userbuf_sz);
MPIU_DBG_MSG_FMT(CH3_OTHER, VERBOSE, (MPIU_DBG_FDEST,
"receive buffer too small; message truncated, msg_sz="
MPIDI_MSG_SZ_FMT ", userbuf_sz="
MPIDI_MSG_SZ_FMT, req->dev.recv_data_sz, userbuf_sz));
req->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_TRUNCATE, "**truncate",
"**truncate %d %d %d %d",
req->status.MPI_SOURCE, req->status.MPI_TAG,
req->dev.recv_data_sz, userbuf_sz);
}
if (!dt_contig) {
MPIDI_msg_sz_t last = 0;
if (req->dev.tmpbuf != NULL) {
last = req->dev.recv_data_sz;
MPID_Segment_unpack(req->dev.segment_ptr, 0, &last, req->dev.tmpbuf);
tmp_buf = req->dev.tmpbuf;
}
else {
mxm_req_buffer_t *iov_buf;
MPL_IOV *iov;
int n_iov = 0;
int index;
last = req->dev.recv_data_sz;
n_iov = req_area->iov_count;
iov_buf = req_area->iov_buf;
if (last && n_iov > 0) {
iov = MPIU_Malloc(n_iov * sizeof(*iov));
MPIU_Assert(iov);
for (index = 0; index < n_iov; index++) {
iov[index].MPL_IOV_BUF = iov_buf[index].ptr;
iov[index].MPL_IOV_LEN = iov_buf[index].length;
}
MPID_Segment_unpack_vector(req->dev.segment_ptr, req->dev.segment_first, &last, iov,
&n_iov);
MPIU_Free(iov);
}
if (req_area->iov_count > MXM_MPICH_MAX_IOV) {
tmp_buf = req_area->iov_buf;
req_area->iov_buf = req_area->tmp_buf;
req_area->iov_count = 0;
}
}
if (last != data_sz) {
MPIR_STATUS_SET_COUNT(req->status, last);
if (req->dev.recv_data_sz <= userbuf_sz) {
/* If the data can't be unpacked, the we have a
* mismatch between the datatype and the amount of
* data received. Throw away received data.
*/
MPIR_ERR_SETSIMPLE(req->status.MPI_ERROR, MPI_ERR_TYPE, "**dtypemismatch");
}
}
}
MPIDI_CH3U_Handle_recv_req(req->ch.vc, req, &complete);
MPIU_Assert(complete == TRUE);
if (tmp_buf)
MPIU_Free(tmp_buf);
return complete;
}
bool SpiralGradPulse::Prepare (const PrepareMode mode) {
bool btag = true;
m_inward = 0;
ATTRIBUTE("Arms" , m_arms);
ATTRIBUTE("MaxSlew" , m_slewrate);
ATTRIBUTE("MaxGrad" , m_max_grad);
ATTRIBUTE("GradSampInt", m_grad_samp_int);
ATTRIBUTE("FOV" , m_fov);
ATTRIBUTE("BandWidth" , m_bw);
ATTRIBUTE("Inward" , m_inward);
if ( mode == PREP_VERBOSE) {
if (!HasDOMattribute("Arms")) {
btag = false;
cout << GetName() << "::Prepare() error: Arms required!!\n";
}
if (!HasDOMattribute("MaxSlew")) {
btag = false;
cout << GetName() << "::Prepare() error: MaxSlew required!!\n";
}
if (!HasDOMattribute("MaxGrad")) {
btag = false;
cout << GetName() << "::Prepare() error: MaxGrad required!!\n";
}
if (!HasDOMattribute("FOV")) {
btag = false;
cout << GetName() << "::Prepare() error: FOV required!!\n";
}
if (!HasDOMattribute("BandWidth")) {
btag = false;
cout << GetName() << "::Prepare() error: BandWidth required!!\n";
}
}
btag = (GradPulse::Prepare(mode) && btag);
if (mode == PREP_VERBOSE) {
double gamma = 42576000.0;
double samp_int = 1.0 / m_bw;
double max_grad_samp = 1000 / (gamma * m_fov * samp_int);
m_pitch = 1000 * m_arms / (2.0 * PI * m_fov);
m_beta = gamma * m_slewrate / m_pitch;
if (m_max_grad/1000 > max_grad_samp) { // Nyquist limit exceeded
cout << "\n warning in Prepare(1) of KVSPIRAL " << GetName() << endl;
cout << "Nyquist limit (" << max_grad_samp << ") exceeded." << endl;
}
double time_of_switch = 0.0;
m_samples = GetDuration() / m_grad_samp_int;
double time = 0.0;
double phi = 0.0;
double max_phi = 0.0;
double klast[3];
double k [3];
double g [3];
double gabs = 0.0;
m_amps.resize(m_samples+1);
k[XC] = 0.0;
k[YC] = 0.0;
k[ZC] = 0.0;
klast[XC] = 0.0;
klast[YC] = 0.0;
klast[ZC] = 0.0;
g[XC] = 0.0;
g[YC] = 0.0;
g[ZC] = 0.0;
m_amps[0] = 0.0;
m_area = 0.;
for (long i = 0; i <= m_samples; i++) {
time = (double) i * m_grad_samp_int / 1000.;
if ( time_of_switch == 0.0 ) // Limited slewrate
phi = m_beta * pow (time, 2.0) / (2.0 + 2.0 * pow(2.0*m_beta/3.0, 1.0/6.0) * pow(time, 1.0/3.0) + pow(2*m_beta/3, 2.0/3.0) * pow(time, 4.0/3.0));
else // Limited gradient
phi = sqrt ( pow(max_phi, 2.0) + 2.0 * (time-time_of_switch) * gamma * m_max_grad / m_pitch * PI / 1000);
k[XC] = m_pitch * phi * sin(phi);
k[YC] = m_pitch * phi * cos(phi);
k[ZC] = m_pitch * phi * sin (phi/3/PI*4) * cos (phi/3/PI*4) * 2;
if (i > 0) {
g[XC] = 10000000. * (k[XC] - klast[XC]) / m_fov * 2. * PI / (gamma * m_grad_samp_int);
g[YC] = 10000000. * (k[YC] - klast[YC]) / m_fov * 2. * PI / (gamma * m_grad_samp_int);
g[ZC] = 10000000. * (k[ZC] - klast[ZC]) / m_fov * 2. * PI / (gamma * m_grad_samp_int);
if (m_axis == AXIS_GX) {
m_amps[i] = g[XC];
m_area += g[XC] * m_grad_samp_int;
} else if (m_axis == AXIS_GY) {
m_amps[i] = g[YC];
m_area += g[YC] * m_grad_samp_int;
} else {
m_amps[i] = g[ZC];
}
gabs = sqrt (pow(g[XC],2.) + pow(g[YC],2.) + pow(g[ZC],2.));
}
klast[XC] = k[XC];
klast[YC] = k[YC];
klast[ZC] = k[ZC];
// Maximum gradient reached?
if (gabs >= m_max_grad && time_of_switch == 0.0) {
m_max_grad = gabs;
time_of_switch = time;
max_phi = phi;
}
}
if (m_inward) {
double* tmp = (double*) malloc ((m_samples+1)*sizeof(double));
std::reverse_copy (&m_amps[0], &m_amps[m_samples], &tmp[0]);
memcpy (&m_amps[0], &tmp[0], sizeof(double)*m_samples);
m_amps[m_samples] = 0.0;
free (tmp);
}
}
if (!btag && mode == PREP_VERBOSE)
cout << "\n warning in Prepare(1) of KVSPIRAL " << GetName() << endl;
return btag;
}
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPID_CH3_INIT);
return mpi_errno;
fn_fail:
if (publish_bc_orig != NULL) {
MPL_free(publish_bc_orig);
}
goto fn_exit;
}
/* This function simply tells the CH3 device to use the defaults for the
MPI Port functions */
int MPIDI_CH3_PortFnsInit( MPIDI_PortFns *portFns ATTRIBUTE((unused)) )
{
MPIU_UNREFERENCED_ARG(portFns);
return 0;
}
/* Perform the channel-specific vc initialization */
int MPIDI_CH3_VC_Init( MPIDI_VC_t *vc ) {
MPIDI_CH3I_VC *vcch = &vc->ch;
vcch->sendq_head = NULL;
vcch->sendq_tail = NULL;
vcch->state = MPIDI_CH3I_VC_STATE_UNCONNECTED;
MPIDI_VC_InitSock( vc );
MPL_DBG_MSG_P(MPIDI_CH3_DBG_CONNECT,TYPICAL,"vc=%p: Setting state (ch) to VC_STATE_UNCONNECTED (Initialization)", vc );
return 0;
}
int MPIDI_CH3I_RMA_Cleanup_target_aggressive(MPIR_Win * win_ptr, MPIDI_RMA_Target_t ** target)
{
int i, local_completed ATTRIBUTE((unused)) = 0, remote_completed = 0;
int made_progress = 0;
MPIDI_RMA_Target_t *curr_target = NULL;
int mpi_errno = MPI_SUCCESS;
(*target) = NULL;
if (win_ptr->states.access_state == MPIDI_RMA_LOCK_ALL_CALLED) {
/* switch to window-wide protocol */
MPIDI_VC_t *orig_vc = NULL, *target_vc = NULL;
MPIDI_Comm_get_vc(win_ptr->comm_ptr, win_ptr->comm_ptr->rank, &orig_vc);
for (i = 0; i < win_ptr->comm_ptr->local_size; i++) {
if (i == win_ptr->comm_ptr->rank)
continue;
MPIDI_Comm_get_vc(win_ptr->comm_ptr, i, &target_vc);
if (orig_vc->node_id != target_vc->node_id) {
mpi_errno = MPIDI_CH3I_Win_find_target(win_ptr, i, &curr_target);
if (mpi_errno)
MPIR_ERR_POP(mpi_errno);
if (curr_target == NULL) {
win_ptr->outstanding_locks++;
mpi_errno = send_lock_msg(i, MPI_LOCK_SHARED, win_ptr);
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
}
}
}
win_ptr->states.access_state = MPIDI_RMA_LOCK_ALL_ISSUED;
}
do {
/* find a non-empty slot and set the FLUSH flag on the first
* target */
/* TODO: we should think about better strategies on selecting the target */
for (i = 0; i < win_ptr->num_slots; i++)
if (win_ptr->slots[i].target_list_head != NULL)
break;
curr_target = win_ptr->slots[i].target_list_head;
if (curr_target->sync.sync_flag < MPIDI_RMA_SYNC_FLUSH) {
curr_target->sync.sync_flag = MPIDI_RMA_SYNC_FLUSH;
}
/* Issue out all operations. */
mpi_errno = MPIDI_CH3I_RMA_Make_progress_target(win_ptr, curr_target->target_rank,
&made_progress);
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
/* Wait for remote completion. */
do {
MPIDI_CH3I_RMA_ops_completion(win_ptr, curr_target, local_completed, remote_completed);
if (!remote_completed) {
mpi_errno = wait_progress_engine();
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
}
} while (!remote_completed);
/* Cleanup the target. */
mpi_errno = MPIDI_CH3I_Win_target_dequeue_and_free(win_ptr, curr_target);
if (mpi_errno != MPI_SUCCESS)
MPIR_ERR_POP(mpi_errno);
/* check if we got a target */
(*target) = MPIDI_CH3I_Win_target_alloc(win_ptr);
} while ((*target) == NULL);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
bool Coil::Prepare (const PrepareMode mode) {
bool success = false;
m_azimuth = 0.0;
m_polar = 0.0;
m_scale = 1.0;
m_norm = 1.0;
m_phase = 0.0;
m_dim = 3;
m_extent = 0;
m_points = 0;
m_complex = false;
m_conjugate = false;
ATTRIBUTE("XPos" , m_position [XC]);
ATTRIBUTE("YPos" , m_position [YC]);
ATTRIBUTE("ZPos" , m_position [ZC]);
ATTRIBUTE("Azimuth", m_azimuth );
ATTRIBUTE("Polar" , m_polar );
ATTRIBUTE("Scale" , m_scale );
ATTRIBUTE("Phase" , m_phase );
ATTRIBUTE("Conj" , m_conjugate );
ATTRIBUTE("Dim" , m_dim );
ATTRIBUTE("Extent" , m_extent );
ATTRIBUTE("Points" , m_points );
m_mode = mode;
m_signal = NULL;
success = Prototype::Prepare(mode);
m_phase *= PI/180.0;
m_polar *= PI/180.0;
m_azimuth *= PI/180.0;
m_interpolate = (m_points>0 && m_extent>0.0);
// dimensions with m_points==0 lead to undefined memory access in vaArray.
if (m_points==0) m_points=1;
m_sensmag = NDData<double> (m_points, m_points, (m_dim==3?m_points:1));
m_senspha = NDData<double> (m_points, m_points, (m_dim==3?m_points:1));
return success;
}
