ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Remove stale component - I'm not going to get to it

Просмотр исходного кода
Этот коммит содержится в:
Ralph Castain 2016-05-07 04:13:34 -07:00
родитель 2839484737
Коммит 6b24e2779b
8 изменённых файлов: 0 добавлений и 649 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

0
ompi/mca/op/x86/.opal_ignore
Просмотреть файл

1
ompi/mca/op/x86/.opal_unignore
Просмотреть файл

@ -1 +0,0 @@
rhc

54
ompi/mca/op/x86/Makefile.am
Просмотреть файл

@ -1,54 +0,0 @@
#
# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# University of Stuttgart. All rights reserved.
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
sources = \
op_x86.h \
op_x86_component.c \
op_x86_module_sum.c
if MCA_BUILD_ompi_op_x86_DSO
lib =
lib_sources =
component = mca_op_x86.la
component_sources = $(sources)
else
lib = libmca_op_x86.la
lib_sources = $(sources)
component =
component_sources =
endif
# Specific information for DSO builds.
#
# The DSO should install itself in $(ompilibdir) (by default,
# $prefix/lib/openmpi).
mcacomponentdir = $(ompilibdir)
mcacomponent_LTLIBRARIES = $(component)
mca_op_x86_la_SOURCES = $(component_sources)
mca_op_x86_la_LDFLAGS = -module -avoid-version
# Specific information for static builds.
#
# Note that we *must* "noinst"; the upper-layer Makefile.am's will
# slurp in the resulting .la library into libmpi.
noinst_LTLIBRARIES = $(lib)
libmca_op_x86_la_SOURCES = $(lib_sources)
libmca_op_x86_la_LDFLAGS = -module -avoid-version

34
ompi/mca/op/x86/configure.m4
Просмотреть файл

@ -1,34 +0,0 @@
# -*- shell-script -*-
#
# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# University of Stuttgart. All rights reserved.
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
# MCA_op_x86_CONFIG([action-if-found], [action-if-not-found])
# -----------------------------------------------------------
AC_DEFUN([MCA_ompi_op_x86_CONFIG],[
AC_CONFIG_FILES([ompi/mca/op/x86/Makefile])
# check for sockaddr_in (a good sign we have TCP)
AC_CHECK_TYPES([struct sockaddr_in],
[$1],
[$2],
[AC_INCLUDES_DEFAULT
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif])
])dnl

80
ompi/mca/op/x86/op_x86.h
Просмотреть файл

@ -1,80 +0,0 @@
/*
* Copyright (c) 2004-2008 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2008-2009 Cisco Systems, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#ifndef MCA_OP_X86_EXPORT_H
#define MCA_OP_X86_EXPORT_H
#include "ompi_config.h"
#include "ompi/mca/mca.h"
#include "opal/class/opal_object.h"
#include "ompi/mca/op/op.h"
BEGIN_C_DECLS
/**
* Flags for each hardware type
*/
typedef enum {
OP_X86_HW_FLAGS_MMX = 1,
OP_X86_HW_FLAGS_MMX2 = 2,
OP_X86_HW_FLAGS_SSE = 4,
OP_X86_HW_FLAGS_SSE2 = 8,
OP_X86_HW_FLAGS_SSE3 = 16
} op_x86_hw_flags_t;
/**
* Derive a struct from the base op component struct, allowing us to
* cache some component-specific information on our well-known
* component struct.
*/
typedef struct {
/** The base op component struct */
ompi_op_base_component_1_0_0_t super;
/* What hardware do we have? */
op_x86_hw_flags_t oxc_hw_flags;
} ompi_op_x86_component_t;
/**
* Derive a struct from the base op module struct, allowing us to
* cache some module-specific information for SUM.
*/
typedef struct {
ompi_op_base_module_1_0_0_t super;
/* JMS need anything here? */
} ompi_op_x86_module_sum_t;
OBJ_CLASS_DECLARATION(ompi_op_x86_module_sum_t);
/**
* Well-known component instance
*/
OMPI_DECLSPEC extern ompi_op_x86_component_t mca_op_x86_component;
/**
* Setup for MPI_MAX and return a module.
*/
OMPI_DECLSPEC ompi_op_base_module_t *ompi_op_x86_setup_sum(ompi_op_t *op);
END_C_DECLS
#endif /* MCA_OP_X86_EXPORT_H */

266
ompi/mca/op/x86/op_x86_component.c
Просмотреть файл

@ -1,266 +0,0 @@
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/*
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2007 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2008-2013 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2015 Los Alamos National Security, LLC. All rights
* reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
/** @file
*
* This is the "x86" component source code. It contains the
* well-known struct that OMPI will dlsym() (or equivalent) for to
* find how to access the rest of the component and any modules that
* are created.
*/
#include "ompi_config.h"
#include "opal/util/output.h"
#include "opal/mca/base/mca_base_var.h"
#include "ompi/constants.h"
#include "ompi/op/op.h"
#include "ompi/mca/op/op.h"
#include "ompi/mca/op/base/base.h"
#include "ompi/mca/op/x86/op_x86.h"
static int x86_component_open(void);
static int x86_component_close(void);
static int x86_component_init_query(bool enable_progress_threads,
bool enable_mpi_threads);
static struct ompi_op_base_module_1_0_0_t *
x86_component_op_query(struct ompi_op_t *op, int *priority);
static int x86_component_register(void);
ompi_op_x86_component_t mca_op_x86_component = {
/* First, the mca_base_component_t struct containing meta
information about the component itself */
{
.opc_version = {
OMPI_OP_BASE_VERSION_1_0_0,
.mca_component_name = "x86",
MCA_BASE_MAKE_VERSION(component, OMPI_MAJOR_VERSION, OMPI_MINOR_VERSION,
OMPI_RELEASE_VERSION),
.mca_open_component = x86_component_open,
.mca_close_component = x86_component_close,
.mca_register_component_params = x86_component_register,
},
.opc_data = {
/* The component is checkpoint ready */
MCA_BASE_METADATA_PARAM_CHECKPOINT
},
.opc_init_query = x86_component_init_query,
.opc_op_query = x86_component_op_query,
},
/* Now comes the x86-component-specific data. In this case,
we'll just leave it blank, defaulting all the values to
0/false/whatever. We'll fill them in with meaningful values
during _component_init_query(). */
};
/*
* Component open
*/
static int x86_component_open(void)
{
opal_output(ompi_op_base_framework.framework_output, "x86 component open");
/* A first level check to see if x86 is even available in this
process. E.g., you may want to do a first-order check to see
if hardware is available. If so, return OMPI_SUCCESS. If not,
return anything other than OMPI_SUCCESS and the component will
silently be ignored.
Note that if this function returns non-OMPI_SUCCESS, then this
component won't even be shown in ompi_info output (which is
probably not what you want).
*/
return OMPI_SUCCESS;
}
/*
* Component close
*/
static int x86_component_close(void)
{
opal_output(ompi_op_base_framework.framework_output, "x86 component close");
/* If x86 was opened successfully, close it (i.e., release any
resources that may have been allocated on this component).
Note that _component_close() will always be called at the end
of the process, so it may have been after any/all of the other
component functions have been invoked (and possibly even after
modules have been created and/or destroyed). */
return OMPI_SUCCESS;
}
/*
* Probe the hardware and see what we have
*/
static void hardware_probe(void)
{
/* ... JMS fill in here ... */
}
static bool x86_mmx_available;
static bool x86_mmx2_available;
static bool x86_sse_available;
static bool x86_sse2_available;
static bool x86_sse3_available;
/*
* Register MCA params.
*/
static int x86_component_register(void)
{
opal_output(ompi_op_base_framework.framework_output, "x86 component register");
/* Probe the hardware and see what we have */
hardware_probe();
x86_mmx_available = (0 != (mca_op_x86_component.oxc_hw_flags & OP_X86_HW_FLAGS_MMX));
(void) mca_base_component_var_register(&mca_op_x86_component.super.opc_version,
"mmx_available", "Whether the hardware supports MMX or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&x86_mmx_available);
x86_mmx2_available = (0 != (mca_op_x86_component.oxc_hw_flags & OP_X86_HW_FLAGS_MMX2));
(void) mca_base_component_var_register(&mca_op_x86_component.super.opc_version,
"mmx2_available", "Whether the hardware supports MMX2 or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&x86_mmx2_available);
x86_sse_available = (0 != (mca_op_x86_component.oxc_hw_flags & OP_X86_HW_FLAGS_SSE));
(void) mca_base_component_var_register(&mca_op_x86_component.super.opc_version,
"sse_available", "Whether the hardware supports SSE or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&x86_sse_available);
x86_sse2_available = (0 != (mca_op_x86_component.oxc_hw_flags & OP_X86_HW_FLAGS_SSE2));
(void) mca_base_component_var_register(&mca_op_x86_component.super.opc_version,
"sse2_available", "Whether the hardware supports SSE2 or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&x86_sse2_available);
x86_sse3_available = (0 != (mca_op_x86_component.oxc_hw_flags & OP_X86_HW_FLAGS_SSE3));
(void) mca_base_component_var_register(&mca_op_x86_component.super.opc_version,
"sse3_available", "Whether the hardware supports SSE3 or not",
MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&x86_sse3_available);
return OMPI_SUCCESS;
}
/*
* Query whether this component wants to be used in this process.
*/
static int x86_component_init_query(bool enable_progress_threads,
bool enable_mpi_threads)
{
opal_output(ompi_op_base_framework.framework_output, "x86 component init query");
/* If we have any hardware and we're not threaded, success */
if (0 != mca_op_x86_component.oxc_hw_flags && !enable_mpi_threads) {
return OMPI_SUCCESS;
}
return OMPI_ERR_NOT_SUPPORTED;
}
/*
* Query whether this component can be used for a specific op
*/
static struct ompi_op_base_module_1_0_0_t *
x86_component_op_query(struct ompi_op_t *op, int *priority)
{
ompi_op_base_module_t *module = NULL;
opal_output(ompi_op_base_framework.framework_output, "x86 component op query");
/* Sanity check -- although the framework should never invoke the
_component_op_query() on non-intrinsic MPI_Op's, we'll put a
check here just to be sure. */
if (0 == (OMPI_OP_FLAGS_INTRINSIC & op->o_flags)) {
opal_output(0, "x86 component op query: not an intrinsic MPI_Op -- skipping");
return NULL;
}
/* What follows is an x86 of how to determine whether your
component supports the queried MPI_Op. You can do this lots of
different ways; this is but one x86. */
/* Note that we *do* have the hardware; _component_init_query()
would not have returned OMPI_SUCCESS if we didn't have the
hardware (and therefore this function would never have been
called). So we don't need to check for the hardware again.
Instead, we need to do finer-grained checks (e.g., do we
support this op, and if so, what datatypes are supported?).
So check to see whether this MPI_Op operation is supported on
the hardware that this component supports (which may involve
querying the hardware to see what it is capable of).
You can see what operation is being requested by checking the
"op->o_f_to_c_index" value against the OMPI_OP_BASE_FORTRAN_*
enums. See ompi/mca/op/op.h for a full list of the
OMPI_OP_BASE_FORTRAN_* enums.
In this x86 component, we support MAX and BXOR. */
switch (op->o_f_to_c_index) {
case OMPI_OP_BASE_FORTRAN_SUM:
/* Corresponds to MPI_SUM */
module = ompi_op_x86_setup_sum(op);
break;
}
/* If we got a module from above, we'll return it. Otherwise,
we'll return NULL, indicating that this component does not want
to be considered for selection for this MPI_Op. Note that the
"setup" functions each returned a *x86* component pointer
(vs. a *base* component pointer -- where an *x86* component
is a base component plus some other module-specific cached
information), so we have to cast it to the right pointer type
before returning. */
if (NULL != module) {
*priority = 25;
}
return (ompi_op_base_module_1_0_0_t *) module;
}

207
ompi/mca/op/x86/op_x86_module_sum.c
Просмотреть файл

@ -1,207 +0,0 @@
/*
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2010 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2008-2009 Cisco Systems, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
/** @file
*
* This is the sum module source code. It contains the "setup"
* functions that will create a module for the MPI_SUM MPI_Op.
*/
#include "ompi_config.h"
#include "opal/class/opal_object.h"
#include "opal/util/output.h"
#include "ompi/constants.h"
#include "ompi/op/op.h"
#include "ompi/mca/op/op.h"
#include "ompi/mca/op/base/base.h"
#include "ompi/mca/op/x86/op_x86.h"
/**
* SUM module struct, including local cached info
*/
typedef struct {
ompi_op_base_module_1_0_0_t super;
/* Fallback function pointers and modules. Only doing a few types
to begin with... will fill in others once we have figured out
the basics of the assembly stuff. */
ompi_op_base_handler_fn_t fallback_float;
ompi_op_base_module_t *fallback_float_module;
ompi_op_base_handler_fn_t fallback_int16_t;
ompi_op_base_module_t *fallback_int16_t_module;
ompi_op_base_handler_fn_t fallback_int32_t;
ompi_op_base_module_t *fallback_int32_t_module;
ompi_op_base_handler_fn_t fallback_int64_t;
ompi_op_base_module_t *fallback_int64_t_module;
} module_sum_t;
/**
* Sum module constructor
*/
static void module_sum_constructor(module_sum_t *m)
{
m->fallback_float = NULL;
m->fallback_float_module = NULL;
m->fallback_int16_t = NULL;
m->fallback_int16_t_module = NULL;
m->fallback_int32_t = NULL;
m->fallback_int32_t_module = NULL;
m->fallback_int64_t = NULL;
m->fallback_int64_t_module = NULL;
}
/**
* Sum module destructor
*/
static void module_sum_destructor(module_sum_t *m)
{
m->fallback_float = (ompi_op_base_handler_fn_t) 0xdeadbeef;
m->fallback_float_module = (ompi_op_base_module_t*) 0xdeadbeef;
m->fallback_int16_t = (ompi_op_base_handler_fn_t) 0xdeadbeef;
m->fallback_int16_t_module = (ompi_op_base_module_t*) 0xdeadbeef;
m->fallback_int32_t = (ompi_op_base_handler_fn_t) 0xdeadbeef;
m->fallback_int32_t_module = (ompi_op_base_module_t*) 0xdeadbeef;
m->fallback_int64_t = (ompi_op_base_handler_fn_t) 0xdeadbeef;
m->fallback_int64_t_module = (ompi_op_base_module_t*) 0xdeadbeef;
}
/**
* Setup the class for the sum module, listing:
* - the name of the class
* - the "parent" of the class
* - function pointer for the constructor (or NULL)
* - function pointer for the destructor (or NULL)
*/
static OBJ_CLASS_INSTANCE(module_sum_t,
ompi_op_base_module_t,
module_sum_constructor,
module_sum_destructor);
/**
* Sum function for C float
*/
static void sum_float(void *in, void *out, int *count,
ompi_datatype_t **type, ompi_op_base_module_t *module)
{
module_sum_t *m = (module_sum_t*) module;
/* Be chatty to the output, just so that we can see that this
function was called */
opal_output(0, "In x86 sum float function");
}
/**
* Sum function for C int16_t
*/
static void sum_int16_t(void *in, void *out, int *count,
ompi_datatype_t **type, ompi_op_base_module_t *module)
{
module_sum_t *m = (module_sum_t*) module;
opal_output(0, "In x86 sum int16_t function");
}
/**
* Sum function for C int32_t
*/
static void sum_int32_t(void *in, void *out, int *count,
ompi_datatype_t **type, ompi_op_base_module_t *module)
{
module_sum_t *m = (module_sum_t*) module;
opal_output(0, "In x86 sum int function");
}
/**
* Sum function for C int64_t
*/
static void sum_int64_t(void *in, void *out, int *count,
ompi_datatype_t **type, ompi_op_base_module_t *module)
{
module_sum_t *m = (module_sum_t*) module;
opal_output(0, "In x86 sum int function");
}
/**
* Setup function for MPI_SUM. If we get here, we can assume that a)
* the hardware is present, b) the MPI thread scenario is what we
* want, and c) the SUM operation is supported. So this function's
* job is to create a module and fill in function pointers for the
* functions that this hardware supports.
*/
ompi_op_base_module_t *ompi_op_x86_setup_sum(ompi_op_t *op)
{
module_sum_t *module = OBJ_NEW(module_sum_t);
/* JMS It might be better to set function pointers here based on
the hardware (MMX*, SSE@) -- i.e., make first layer decision of
which will be used. I don't know if that's Right, though,
because we might want to dispatch to different hardware based
on the size of the operation...? Just recording the idea
here... */
/* Commenting out everything for the moment, just so that we can
focus on the hardware detection piece first. */
#if 0
/* C float */
module->super.opm_fns[OMPI_OP_BASE_TYPE_FLOAT] = sum_float;
module->fallback_float = op->o_func.intrinsic.fns[OMPI_OP_BASE_TYPE_FLOAT];
module->fallback_float_module =
op->o_func.intrinsic.modules[OMPI_OP_BASE_TYPE_FLOAT];
/* If you cache a fallback function, you *must* RETAIN (i.e.,
increase the refcount) its module so that the module knows that
it is being used and won't be freed/destructed. */
OBJ_RETAIN(module->fallback_float_module);
/* C int16_t */
module->super.opm_fns[OMPI_OP_BASE_TYPE_INT16_T] = sum_int16_t;
module->fallback_int16_t = op->o_func.intrinsic.fns[OMPI_OP_BASE_TYPE_INT16_T];
module->fallback_int16_t_module =
op->o_func.intrinsic.modules[OMPI_OP_BASE_TYPE_INT16_T];
/* If you cache a fallback function, you *must* RETAIN (i.e.,
increase the refcount) its module so that the module knows that
it is being used and won't be freed/destructed. */
OBJ_RETAIN(module->fallback_int16_t_module);
/* C int32_t */
module->super.opm_fns[OMPI_OP_BASE_TYPE_INT32_T] = sum_int32_t;
module->fallback_int32_t = op->o_func.intrinsic.fns[OMPI_OP_BASE_TYPE_INT32_T];
module->fallback_int32_t_module =
op->o_func.intrinsic.modules[OMPI_OP_BASE_TYPE_INT32_T];
/* If you cache a fallback function, you *must* RETAIN (i.e.,
increase the refcount) its module so that the module knows that
it is being used and won't be freed/destructed. */
OBJ_RETAIN(module->fallback_int32_t_module);
/* C int64_t */
module->super.opm_fns[OMPI_OP_BASE_TYPE_INT64_T] = sum_int64_t;
module->fallback_int64_t = op->o_func.intrinsic.fns[OMPI_OP_BASE_TYPE_INT64_T];
module->fallback_int64_t_module =
op->o_func.intrinsic.modules[OMPI_OP_BASE_TYPE_INT64_T];
/* If you cache a fallback function, you *must* RETAIN (i.e.,
increase the refcount) its module so that the module knows that
it is being used and won't be freed/destructed. */
OBJ_RETAIN(module->fallback_int64_t_module);
#endif
return (ompi_op_base_module_t*) module;
}

7
ompi/mca/op/x86/owner.txt
Просмотреть файл

@ -1,7 +0,0 @@
#
# owner/status file
# owner: institution that is responsible for this package
# status: e.g. active, maintenance, unmaintained
#
owner: INTEL
status: maintenance