In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
/*
|
2007-03-29 05:00:33 +04:00
|
|
|
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
|
2005-11-05 22:57:48 +03:00
|
|
|
* University Research and Technology
|
|
|
|
|
* Corporation. All rights reserved.
|
2006-08-23 04:29:35 +04:00
|
|
|
* Copyright (c) 2004-2006 The University of Tennessee and The University
|
2005-11-05 22:57:48 +03:00
|
|
|
* of Tennessee Research Foundation. All rights
|
|
|
|
|
* reserved.
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
* 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$
|
|
|
|
|
*
|
|
|
|
|
* Additional copyrights may follow
|
|
|
|
|
*
|
|
|
|
|
* $HEADER$
|
|
|
|
|
*/
|
|
|
|
|
/**
|
|
|
|
|
* @file
|
|
|
|
|
*
|
|
|
|
|
* This file will hopefully not last long in the tree, but it's
|
|
|
|
|
* unfortunately necessary for now.
|
|
|
|
|
*
|
|
|
|
|
* There are multiple places in the code base where we need to safely
|
|
|
|
|
* convert from a size_t to an int. However, on some platforms,
|
|
|
|
|
* sizeof(size_t) is larger than sizeof(int), so casting from size_t
|
|
|
|
|
* -> int will result in a compiler warning and potentially data
|
|
|
|
|
* truncation.
|
|
|
|
|
*
|
|
|
|
|
* But, unfortunately, we still need to do it. But we definitely do
|
|
|
|
|
* not want compiler warnings. So when sizeof(size_t)>sizeof(int),
|
|
|
|
|
* the solution is the treat the size_t value like an array and
|
|
|
|
|
* dereference the appropriate nibble and cast that to an int (which
|
|
|
|
|
* accounts for both big and little endian machines).
|
|
|
|
|
*
|
|
|
|
|
* Most places in the code where this casting must occur are because
|
|
|
|
|
* collision of APIs (e.g., one API requires a size_t and another API
|
|
|
|
|
* requires an int. And in most places, we're not going to overflow
|
|
|
|
|
* the int when casting down into it (e.g., it's the result of a
|
|
|
|
|
* strlen, or the length of the buffer in an ompi_buffer_t -- if that
|
|
|
|
|
* buffer is larger than MAX_INT, we've got other problems!).
|
|
|
|
|
*
|
|
|
|
|
* BUT -- the whole premise of casting down to an int is dangerous.
|
|
|
|
|
* So we provide extra protection here to detect overflow situations
|
|
|
|
|
* and print out appropriate warnings. So if this situation ever
|
|
|
|
|
* occurs, we'll still overflow, but we'll have a good indication that
|
|
|
|
|
* it's happening, and where.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef OPAL_CONVERT_H
|
|
|
|
|
#define OPAL_CONVERT_H
|
|
|
|
|
|
2006-02-12 04:33:29 +03:00
|
|
|
#include "opal_config.h"
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
|
2007-07-01 21:51:34 +04:00
|
|
|
BEGIN_C_DECLS
|
2006-08-23 04:29:35 +04:00
|
|
|
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
/**
|
|
|
|
|
* Convert a size_t to an int.
|
|
|
|
|
*
|
|
|
|
|
* @param in The size_t value to be converted
|
|
|
|
|
* @param out The output int value.
|
|
|
|
|
* @param want_check Whether to check for truncation or not
|
|
|
|
|
*
|
2007-03-29 05:00:33 +04:00
|
|
|
* @returns OPAL_SUCESS If all went well
|
|
|
|
|
* @returns OPAL_NOT_SUPPORTED if the size_t value was truncated
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
*
|
|
|
|
|
* The conversion will always occur. However, if the size_t value was
|
|
|
|
|
* truncated (i.e., sizeof(size_t) > sizeof(int), and the cast down to
|
2007-03-29 05:00:33 +04:00
|
|
|
* the int actually changed the value), OPAL_NOT_SUPPORTED will be
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
* returned.
|
|
|
|
|
*
|
|
|
|
|
* On platforms where sizeof(size_t) <= sizeof(int), this function
|
2006-02-12 04:33:29 +03:00
|
|
|
* will aways return OPAL_SUCCESS.
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
*/
|
2007-03-20 16:01:32 +03:00
|
|
|
OPAL_DECLSPEC int opal_size2int(size_t in, int *out, bool want_check) __opal_attribute_nonnull__(2);
|
2006-08-23 04:29:35 +04:00
|
|
|
|
2007-07-01 21:51:34 +04:00
|
|
|
END_C_DECLS
|
In comm.c, one of the few places where OMPI and ORTE interact, we have
a clash of APIs -- MPI requires int's, but the ORTE DPS requires
size_t's. Specifically, we need to orte_dps.unload(), which fills a
size_t. We then need to PML send (i.e., MPI_Send) that value around.
However, there's no such thing as MPI_SIZE_T as a datatype, and that
would hose us in heterogeneous situations, anyway. So the compromise
was to make ompi_sizet2int(), a function what does the [potenial]
downcast. On 32 bit architectures, this is no big deal -- it's a
simple assignment. On 64 bit architectures (or, more specifically,
where sizeof(size_t) > sizeof(int)), it does the dowcast in a
compiler-safe manner, and does a check to see if we truncated. If we
truncated, in a developer build, we'll abort(). If this is not a
developer build, print out a nasty warning.
The rationale here is as followes:
- this is a clash of the API's. There's unfortunately nothing that we
can do about this at the moment.
- hence, we have to do the downcast.
- but we might as well be "safe" about it -- assuming that
orte_dps.unload() never gives us back a value >sizeof(int) (which is
a pretty safe assumption -- if we get that large of a value, we have
other problems, or we're on fundamentally different types of
hardware and I suspect a lot of the rest of the code base will have
problems as well!), we should be able to downcast safely.
- if there is a mistake in code somewhere such that:
- we can't downcast safely (i.e., we legitmately have a size_t value
that is too large for an int)
- we truncate when the value should not have been that large
the conversion function will detect this and print out an error. So
we won't silently introduce any new errors into the code base --
they will be loud and obvious.
- although comm.c is currently the only place where we need this, I
suspect that there will be a small number of other places where
similar situations occur. I intend to bring this right over to the
trunk, so it was simpler to make this functionality be a subroutine
so that we can use it elsewhere if/when necessary.
Final note: src/attribute/attribute.c does something *similar*
(downcasting when sizeof(void*) > sizeof(int), but is different enough
that it would have been painful to make one unified interface. This
does not rule it out for the future, however (especially if we find
more places in the tree that need this kind of functionality).
This commit was SVN r6246.
2005-07-01 01:30:18 +04:00
|
|
|
|
|
|
|
|
#endif
|