Changes between Version 7 and Version 8 of MapGuideRfc116


Ignore:
Timestamp:
Jun 27, 2011, 1:36:02 PM (13 years ago)
Author:
NormOlsen
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • MapGuideRfc116

    v7 v8  
    1 = !MapGuide RFC 116 - Coordinate System COnversion Perfromance Upgrade =
     1= !MapGuide RFC 116 - Coordinate System Conversion Performance Upgrade =
    22
    33This page contains an change request (RFC) for the !MapGuide Open Source project.
     
    3333The proposed submission would not change any existing method signatures or change any behavior in a substantial way.  The proposal introduces five new members to the currently existing MgCoordinateSystemTransform interface.  This RFC includes an outline of the recommended usage of the API which will provide the optimum performance of the API.
    3434
    35 Using the metric of the number of conversions per second from UTM27-13 to CO83-C in a pure measurement environment (i.e. no coordinate retrieval or delivery code), the underlying CS-MAP library is capable of producing approximately 1 million conversions per second.  Changes in the MapGuide API, therefore, cannot get us beyond this limit.  Thus, in this RFC, we will write of performance in terms of the percentage of this theoretical maximum which the API can/will deliver.  The current implementation of the API delivers performance of approximately 80% of this maximum.  Research and test implementations indicate that it is not unreasonable to expect an improvement to 91% of the theoretical maximum when using the most efficient of the Transform function overloads.
     35Using the metric of the number of conversions per second from UTM27-13 to CO83-C in a pure measurement environment (i.e. no coordinate retrieval or delivery code), the underlying CS-MAP library is capable of producing approximately 1 million conversions per second on an average desktop machine.  Changes in the MapGuide API, therefore, cannot get us beyond this limit.  Thus, in this RFC, we will write of performance in terms of the percentage of this theoretical maximum which the API can/will deliver.  The current implementation of the API delivers performance of approximately 80% of this maximum.  Research and test implementations indicate that it is not unreasonable to expect an improvement to 91% of the theoretical maximum when using the most efficient of the Transform function overloads.
    3636
    37 Achieving this level of improvement is deemed possible by four distinct tasks involving the API.
     37Achieving this level of improvement is deemed possible by five distinct tasks involving the API.
    3838
    39 === Removing the Requirement for a Crtitical Section ===
     39=== Removing the Requirement for a Critical Section ===
    4040
    4141Currently, there are specific transformations within the CS-MAP library which are not reentrant.  Therefore, to insure proper operation in a multi-threaded environment, a critical section is used for all datum shift calculations.  It is the intent of this RFC to remove this requirement.  Assuming the acceptance and implementation of OsGeo MetaCRS RFC !#5, CS-MAP will enable the API to query CS-MAP and determine if a critical section is necessary for a specific transformation.  The API will be modified to use this information and invoke the critical section only as necessary.
     
    4848{{{ bool MgCoordinateSystemTransform::IsReentrant (); }}}
    4949
    50 The function would return true only in the case where all conversions and transformations referenced by the transformation object are known to be reentrant.
     50The function would return true only in the case where all conversions and transformations referenced by the transformation object have been classified as reentrant.
    5151
    52 === Refactor the MgCoordinateSystemTransformation::Transform Functions ===
     52=== Refactor the MgCoordinateSystemTransform::Transform Functions ===
    5353
    5454It is proposed that the existing implementation of all of the Transform overloads in the existing MgCoordinateSystemTransformation object be refactored for optimum performance purposes.  It is contemplated that by : a) reducing the number of changes the form of a coordinate takes, b) removing some internal function calls by replicating code to a small degree, and c) reducing the overhead implied by several layers of try {} catch blocks; that significant performance enhancements can be achieved.  This work will introduce some minor changes in behavior which are considered to be improvements in consistency and usefulness of the API and only affects behavior in extraordinary cases.  These changes are detailed below.
     
    5656=== Conversion Status Accumulation ===
    5757
    58 CS_MAP issues warnings for coordinates outside the useful range of the coordinate systems (and the datums referenced by them) used to construct the MgCoordinateSystemTransformation object.  These are warnings and do not mean that the returned coordinates are invalid.  It should '''not''' be considered abnormal for a small sub-set of the coordinates in a large conversion to be outside the useful range of a Transformation object.  In the event that a large number of coordinates in a conversion are found to be outside the useful range, it is proper to question the validity of the conversion.  Such a case is a strong indication that the user may not have selected the proper coordinate system for a specific conversion.
     58CS_MAP issues warnings for coordinates outside the useful range of the coordinate systems (and the datums referenced by them) used to construct the MgCoordinateSystemTransform object.  These are warnings and do not mean that the returned coordinates are invalid.  It should '''not''' be considered abnormal for a small sub-set of the coordinates in a large conversion to be outside the useful range of a Transformation object.  In the event that a large number of coordinates in a conversion are found to be outside the useful range, it is proper to question the validity of the conversion.  Such a case is a strong indication that the user may not have selected the proper coordinate system for a specific conversion.
    5959
    60 The default behavior of the API is to throw an exception whenever such a warning is received from the CS-MAP library.  This default behavior can be, and often is, modified at run-time using the IgnoreDatumShiftWarning and IgnoreOutsideDomainWarning members of the MgCoordinateSystem interface.  Thus, it is recommended that applications using the API disable the exception throwing behavior of the API.  It is further proposed that the MgCoordinateSystemTransformation object be enhanced to provide a status accumulation feature.  By status accumulation, we refer to the concept of: a)counting each point converted, b) counting all source projective CRS warnings issued, c) counting all datum shift warnings issued, and d) counting all target projective CRS warnings.
     60The default behavior of the API is to throw an exception whenever such a warning is received from the CS-MAP library.  This default behavior can be, and often is, modified at run-time using the IgnoreDatumShiftWarning and IgnoreOutsideDomainWarning members of the MgCoordinateSystem interface.  Thus, it is recommended that applications using the API disable the exception throwing behavior of the API.  It is further proposed that the MgCoordinateSystemTransform object be enhanced to provide a status accumulation feature.  By status accumulation, we refer to the concept of: a) counting all source projective CRS warnings issued, b) counting all datum shift warnings issued, and c) counting all target projective CRS warnings.
    6161
    62 Upon construction, or upon use of the SetSourceAndTarget member function, or upon use of the ResetLastTransformStatus member function, all counters of the status accumulation mechanism will be reset to zero.  Each point converted by the MgCoordinateSystemTransformation object will cause the all appropriate counts to be advanced based on the status of the conversion.  Upon completion of the conversion of a map or data source, the application will then query the Transformation object and make a determination as to the validity of the result.
     62Upon construction, or upon use of the SetSourceAndTarget member function, or upon use of the ResetLastTransformStatus member function, all counters of the status accumulation mechanism will be reset to zero.  Each point converted by the MgCoordinateSystemTransform object will cause the appropriate counts to be advanced based on the status of the conversion.  Upon completion of the conversion of a map or data source, the application would then query the Transformation object and make a determination as to the validity of the result.
    6363
    64 For example, a conversion where the target CRS warning count exceeds, say, 33% of the total number of points suggests that the target CRS chosen by the user is incorrect.  On the other hand, warning counts which are less than, say, 10% of the total point count suggest a perfectly normal conversion.
     64For example, a conversion where the target CRS warning count exceeds, say, 20% of the total number of points suggests that the target CRS chosen by the user is incorrect.  On the other hand, warning counts which are less than, say, 20% of the total point count suggest a perfectly normal conversion.
    6565
    66 Thus, the following additional member functions to the MgCoordinateSystemTransformation object are proposed:
    67 
    68 {{{ INT32 MgCoordinateSystemTransform::GetConversionStatus (INT32 failPercentage); }}}
    69 
    70 The argument to this function would indicate the threshold as the percentage of points converted which are to be considered a transformation failure.  The returned integer would be zero for a successful conversion.  A non-zero bitmap of would be returned in the event of a failure (i.e. a warning count excess the specified percentage of the total point count), the individual bits indicating the phase, or phases, (i.e. source CRS, datum shift, target CRS) which accumulated sufficient warning counts to indicate failure.
    71 
    72 {{{ INT32 MgCoordinateSystemTransform::GetTotalPointCount (void); }}}
    73 
    74 Returns the total number of points converted.
     66Thus, the following additional member functions to the MgCoordinateSystemTransform object are proposed:
    7567
    7668{{{ INT32 MgCoordinateSystemTransform::GetSourceWarningCount (void); }}}
     
    9082The addition of this improved status monitoring capability is expected to make the disabling of exception processing while performing large conversions an acceptable practice and is, therefore, considered to be and important contribution to providing higher performance levels.
    9183
    92 === Provide Addiional Batch Coordinate Conversion Capability ===
     84=== Provide Additional Batch Coordinate Conversion Capability ===
    9385
    94 A batch coordinate conversion capability currently exists in the MgCoordinateSystemTransformation object.  The performance of this capability is expected to increase due to the refactoring of the Transform code proposed immediately above.  However, this function requires that, for example, 3D coordinates are provided in three distinct arrays; specifically the easting/X/Longitude coordinates in one single dimensional array of doubles, the northing/Y/Latitude coordinates in a separate single dimension array of doubles, and a third separate and distinct array of double for the elevation/Z/height coordinate.  There are few, if any, applications which maintain or utilize coordinate data in this form.
     86A batch coordinate conversion capability currently exists in the MgCoordinateSystemTransform object.  The performance of this capability is expected to increase due to the refactoring of the Transform code proposed immediately above.  However, this function requires that, for example, 3D coordinates are provided in three distinct arrays; specifically the easting/X/Longitude coordinates in one single dimensional array of doubles, the northing/Y/Latitude coordinates in a separate single dimension array of doubles, and a third separate and distinct array of double for the elevation/Z/height coordinate.  There are few, if any, applications which maintain or utilize coordinate data in this form.
    9587
    96 Thus, to take advantage of the batch conversion facility currently in place, the traditional form of coordinate data (e.g. a two dimensional array of doubles: ''double []![3]'') has to be reformatted (i.e. marshalled) into the distinct array form prior to conversion, and then reformatted back to the traditional form after the conversion has been performed.  Thus, what performance improvement is provided by the batch conversion facility is typically consumed, and probably then some, by the formatting and reformatting processes.
     88Thus, to take advantage of the batch conversion facility currently in place, the traditional form of coordinate data (e.g. a two dimensional array of doubles: ''double []![3]'') has to be reformatted (i.e. marshaled) into the distinct array form prior to conversion, and then reformatted back to the traditional form after the conversion has been performed.  Thus, what performance improvement is provided by the batch conversion facility is typically consumed, and probably then some, by the formatting and reformatting processes.
    9789
    98 It is, therefore proposed, that two new functions be added to the MgCoordinateSystemTransformation object be added which will have signatures suggested by the following:
     90It is, therefore proposed, that two new functions be added to the MgCoordinateSystemTransform object be added which will have signatures suggested by the following:
    9991
    10092{{{
    101     void MgCoordinateSystemTransform::Transform2D (double [][2],INT32 pointCount);
    102     void MgCoordinateSystemTransform::Transform3D (double [][3],INT32 pointCount);
     93void MgCoordinateSystemTransform::Transform2D (double [][2],INT32 pointCount);
     94void MgCoordinateSystemTransform::Transform3D (double [][3],INT32 pointCount);
    10395}}}
    10496
    10597These new member functions would convert the point arrays in place, and do so without the need for reformatting the coordinate storage.
     98
     99=== Single Thread Operation ===
     100
     101It is expected that the above changes will improve the performance of the coordinate conversion API without changing its behavior in a multi-threaded environment.  It is considered likely that further performance enhancements can be achieved if the MgCoordinateSystemTransform object can assume that it is operating in a single threaded environment.  Thus, the following new member of the MgCoordinateSystemTransform interface is also proposed:
     102
     103{{{
     104bool MgCoordinateSystemTransform::AssumeSingleThread (bool true);
     105}}}
     106
     107This function would inform the MgCoordinateSystemTransform object that the current instance may assume it is operating in a single thread environment, and thus deliver any extra performance it can under that assumption.  The member will return the previous state of the AssumeSingleThread flag.
    106108
    107109== Implications ==
     
    111113It would be nice to assume that all current CS-MAP coordinate conversion algorithms can be made reentrant without a serious affect on resources and/or performance, and that all future additions to the CS-MAP library will be implemented in a reentrant manner.  However, the ability to have non-reentrant conversion/transformation methods in the CS-MAP library is reserved.  Thus, we retain the Critical Section to keep multiple threads from using a non-reentrant conversion or transformation at the same time.  Given the implementation of CS-MAP RFC !#5, however, we will only need to actually use it when truly necessary.
    112114
     115=== Reentrancy ===
     116
     117The reentrancy of all existing features of the MgCoordinateSystemTransform object remain intact; although it is expected that several minor behavior changes (the author considers them to be improvements) will be made as described immediately below.  The new status accumulation feature, however, cannot be made totally reentrant in the current MapGuide environment due to multi-platform, multi-language, support considerations.
     118
     119That is, the status count feature cannot be implemented in an a "separate instance per thread" manner and passed to a reentrant MgCoordinateSystemTransform object.  Thus, the data elements in which the status accumulation occurs must be included in the Transform object itself.  This leads to the fact that using the same Transform object for the conversion for two distinct datasets (as would be possible if total reentrancy was achievable) will produce the correct numerical results, but all status warnings encountered in the two different datasets would be accumulated in the same data accumulation variables and thus conversion of a dataset which converted without warning be considered a failure due to the failure of the second dataset.
     120
     121Conversion of a very large dataset, a point cloud for example, can be achieved in a multi-threaded environment using the same MgCoordinateSystemTransform object as the resulting status accumulation will accurately reflect that status of the entire conversion effort.  As this is possible and desirable, we propose this as the optimum balance of performance versus functionality.
     122
    113123=== Behavior Modifications ===
    114124
    115125A substantial portion of the increased performance to be achieved will be derived from a refactoring of the coordinate system conversion code.  Over the years, this code has become somewhat inefficient using several nested function calls with non-trivial signatures.  In refactoring this code, the following changes in behavior (more like corrections) will be made:
    116  1. In the existing code, the behavior of the API with regard to the status of returned results in the event of an exception being thrown is inconsistent.  In the proposed code, the basic CS-MAP contract will be honored: “Regardless of status returned and/or exceptions thrown, any and all Transform member calls will always produce rational converted results.”   Thus, the proposed behavior will provide consistent return results and also contribute to higher performance levels.  That is, even in the event of an exception, all coordinates requested to be convrted will have been conververted.
    117  2. The four status values returned in the m_nTransformStatus member of the MgCoordinateSystemTransform object may be adjusted to form a severity level sequence which rates a geodetic datum “outside range” as more severe than a projected “outside range”.  The names used will not change, only the numeric values assigned to them; so this should not require any coding changes.
    118  3. The overloads of the MgCoordinateSystemTransform::Transform which deal with arrays will now always complete the conversion of the entire array before throwing any exception with regard to non-normal status encountered in the conversion.  Also, these overloads will be modified so that the value of the m_nTransformStatus member, upon return, will always reflect the worst status encountered (per the severity level described in 2 above) in the transformation of the array (as opposed to the status of the last conversion perfromed as is currently done).
     126 1. In the existing code, the behavior of the API with regard to the status of returned results in the event of an exception being thrown is inconsistent.  In the proposed code, conversion results will always be provided, even in the event of an exception being thrown.  Thus, the proposed behavior will provide consistent return results and also contribute to higher performance levels.  That is, even in the event of an exception, all coordinates requested to be converted will have been converted.
     127 2. The four status values returned in the m_nTransformStatus member of the MgCoordinateSystemTransform object will be adjusted to form a severity level sequence which rates a geodetic datum “outside range” as more severe than a projected “outside range”.  The names used will not change, only the numeric values assigned to them; so this should not require any coding changes.
     128 3. The overloads of the MgCoordinateSystemTransform::Transform which deal with arrays will now always complete the conversion of the entire array before throwing any exception with regard to non-normal status encountered in the conversion.  Also, these overloads will be modified so that the value of the m_nTransformStatus member, upon return, will always reflect the worst status encountered (per the severity level described in 2 above) in the transformation of the array (as opposed to the status of the last conversion performed as is currently done).
    119129 4. All overloads of the TransformM variety will now always calculate and return the ‘m’ value.  Currently, when an exception is thrown, the XYZ coordinate values would be converted, but the ‘m’ value would not always be.
     130
     131Coordinate results provided in the case of an exception will be what CS-MAP considers to be a "rational result".  In the case of a datum shift calculation failure, the rational result is either than calculated by the fallback specification or the unshifted input coordinates.  This is considered rational as datums shifts are rarely more than 100 meters, and often in the range of 20 meters.  Thus, given that the input coordinate is outside the useful range of the datum shift transformation (typically this means outside the coverage provided by grid shift data files), the result "rational result" is the unshifted input.
     132
     133In the case of projective conversions, the "rational result" is based on the nature of the projection. For many of the projections supported, the "rational result" is simply what the projection mathematics produce, even though the coordinate is known to be outside the region for which the projection's parameters suggest is the useful range of the conversion.  In other cases, the projection will have singularity points, such as either pole in the case of the traditional Mercator.  In such cases the "rational result" typically includes one or more coordinates with an unmistakably large number which suggests infinity, but will not cause a floating point exception if the value is used for any normal calculation.
    120134
    121135== Test Plan ==