0

我们正在做一个高性能计算项目，它使用 MPI 作为并行计算框架。遗留平台上已经实现了一些算法。我们所做的是将原来的串行算法重写为基于 MPI 的并行版本。

我遇到了这个性能问题：当运行基于 MPI 的并行算法时，多个进程之间有很多通信开销。进程间通信由三个步骤组成：

  1. 进程 A 将一些 C++ 对象序列化为二进制格式。
  2. 进程 A 通过 MPI 向进程 B 发送二进制格式的数据。
  3. 进程 B 将二进制格式数据反序列化为 C++ 对象。

我们发现这些通信步骤，尤其是序列化/反序列化步骤，会花费大量时间。我们如何处理这个性能问题？

顺便说一句，在我们的 C++ 代码中，我们使用了很多 STL，它比 C 类结构更复杂。

PS我现在通过编写代码遍历对象的所有字段并将它们按顺序复制到字节数组中来执行此操作（序列化）。

为了演示我在做什么，有一个代码片段。请注意，这只是一个单一的特征构建过程：

sic::GeometryFeature *ptFeature =
    (GeometryFeature *) outLayer->getFeature(iFeature);
sic::Geometry* geom = ptFeature->getGeometry();
std::string geomClassName = geom->getClassName();

sic::Geometry* ptGeom = geom;
unsigned char *wkbBuffer = NULL;
OGRGeometry * gtGeom = NULL;
if (geomClassName == "Point") {
    ptGeom = new sic::MultiPoint();
    ((sic::MultiPoint *) ptGeom)->insert(geom);
    gtGeom = new OGRMultiPoint();
    int wkbSize = ((sic::MultiPoint *) ptGeom)->WkbSize();
    wkbBuffer = (unsigned char *) malloc(wkbSize);
    ((sic::GeometryCollection *) ptGeom)->exportToWkb(sic::wkbNDR,
        wkbBuffer, wkbMultiPoint);
}
} else if (...) {
    ......
}
gtGeom->importFromWkb(wkbBuffer);
free(wkbBuffer);
assert(gtGeom);
OGRFeature * poFeature = OGRFeature::CreateFeature(
     poLayer->GetLayerDefn());
poFeature->SetGeometry(gtGeom);

还有更多关于我在做什么序列化对象：

unsigned char *bytes = (unsigned char *) malloc(size);
    size_t offset = 0;

    size_t type_size = sizeof(OGRwkbGeometryType);
    OGRwkbGeometryType type = layer->GetGeomType();
    memcpy(bytes + offset, &type, type_size);
    offset += type_size;

    size_t count_size = sizeof(int);
    int count = layer->GetFeatureCount();
    memcpy(bytes + offset, &count, count_size);
    offset += count_size;

    layer->ResetReading();
    for (OGRFeature *feature = layer->GetNextFeature(); feature != NULL;
            feature = layer->GetNextFeature()) {
        OGRGeometry *geometry = feature->GetGeometryRef();
        if (geometry) {
            geometry->exportToWkb(wkbNDR, bytes + offset);
            offset += geometry->WkbSize();
        } else {
            (*(int *) (bytes + type_size))--;
        }
        OGRFeature::DestroyFeature(feature);
    }

    return bytes;

任何评论将不胜感激。谢谢！

4

1 回答 1

1

（Brian 的回答是帮助您使用库......他是一位非常有经验的程序员 - 听起来值得一试。）

另外，我查看了您的代码 - 有很多临时缓冲区、新/malloc 分配、使用sizeof等。所以我想我会说明一个“快速、简单但很好”的清理方法 - 足以希望让你开始...

首先创建一个二进制流类型，它考虑并隐藏了许多低级工作：

#include <arpa/inet.h> // for htonl/s, ntoh/s
#include <endian.h> // for htonbe64, if you have it...

#include <iostream>
#include <string>
#include <map>

// support routines - use C++ overloading to polymorphically dispatch htonl/s

// uint64_t hton(uint64_t n) { return htonbe64(n); }
uint32_t hton(uint32_t n) { return htonl(n); }
uint16_t hton(uint16_t n) { return htons(n); }

// there are no "int" versions - this is ugly but effective...
uint32_t hton(int32_t n) { return htonl(n); }
uint16_t hton(int16_t n) { return htons(n); }

// uint64_t ntoh(uint64_t n) { return betoh64(n); }
uint32_t ntoh(uint32_t n) { return ntohl(n); }
uint16_t ntoh(uint16_t n) { return ntohl(n); }

template <typename OStream>
class Binary_OStream : public OStream
{
  public:
    typedef Binary_OStream This;

    This& write(const char* s, std::streamsize n)
    {
        OStream::write(s, n);
        return *this;
    }

    template <typename T>
    This& rawwrite(const T& t)
    {
        static_cast<OStream&>(*this) << '[' << sizeof t << ']';
        return write((const char*)&t, sizeof t);
    }

    template <typename T>
    This& hton(T h)
    {
        T n = ::hton(h);
        return rawwrite(n);
    }

    // conversions for inbuilt & Standard-library types...

    friend This& operator<<(This& bs, bool x) { return bs << (x ? 'T' : 'F'); }
    friend This& operator<<(This& bs, int8_t x) { return bs << x; }
    friend This& operator<<(This& bs, uint8_t x) { return bs << x; }
    friend This& operator<<(This& bs, int16_t x) { return bs.hton(x); }
    friend This& operator<<(This& bs, uint16_t x) { return bs.hton(x); }
    friend This& operator<<(This& bs, int32_t x) { return bs.hton(x); }
    friend This& operator<<(This& bs, uint32_t x) { return bs.hton(x); }

    friend This& operator<<(This& bs, double d) { return bs.rawwrite(d); }

    friend This& operator<<(This& bs, const std::string& x)
    {
        bs << x.size();
        return bs.write(x.data(), x.size());
    }

    template <typename K, typename V, typename A>
    friend This& operator<<(This& bs, const std::map<K, V, A>& m)
    {
        typedef typename std::map<K, V, A>::const_iterator It;

        bs << m.size();

        for (It it = m.begin(); it != m.end(); ++it)
            bs << it->first << it->second;

        return bs;
    }

    // add any others you want...
};

创建用户定义的二进制可序列化类型...

// for your own objects...    
struct Object
{
    Object(const std::string& s, double x) : s_(s), x_(x) { }

    std::string s_;
    double x_;

    // specify how you want binary serialisation performed (which fields/order etc)
    template <typename T>
    friend Binary_OStream<T>& operator<<(Binary_OStream<T>& os, const Object& o)
    {
        return os << o.s_ << o.x_;
    }
};

示例用法：

#include <iomanip>
#include <sstream>

// support routines just to help you observe/debug the serialisation...

std::string printable(char c)
{
    std::ostringstream oss;
    if (isprint(c))
        oss << c;
    else
        oss << "\\x" << std::hex << std::setw(2) << std::setfill('0')
            << (int)(uint8_t)c << std::dec;
    return oss.str();
}

std::string printable(const std::string& s)
{
    std::string result;
    for (std::string::const_iterator i = s.begin(); i != s.end(); ++i)
        result += printable(*i);
    return result;
}

int main()
{
    {
        Binary_OStream<std::ostringstream> bs;

        Object o("pi", 3.14);

        bs << o;

        std::cout << "serialised to '" << printable(bs.str()) << "'\n";
    }

    {
        Binary_OStream<std::ostringstream> bs;

        std::map<int, std::string> m;
        m[0] = "zero";
        m[1] = "one";
        m[2] = "two";
        bs << m;

        std::cout << "serialised to '" << printable(bs.str()) << "'\n";
    }
}

下一步是创建一个Binary_IStream- 它与上述非常非常相似。（boost通过使用 '%' 运算符而不是传统的<<and来减少工作量>>，这样同一个函数就可以指定用于序列化和反序列化的字段。）

实施说明/想法：

  • 如果您愿意，可以从 Binary_Stream 中删除模板参数，并让构造函数将任意值存储std::ostream&到private成员变量中，然后将所有流操作发送到该数据成员。
    • 这具有最大程度地减少不同流类型实例化的代码膨胀的优点，允许对翻译单元隐藏实现并稍后链接（有助于在大型项目中缩短编译时间），并让您只需将 a 附加Binary_Stream到任何现有流随时（如果有人向您传递预先存在的流，那就太好了）。
    • “缺点”是您必须明确地转发到ostream您希望Binary_Stream用户访问的任何其他成员函数（更多控制但乏味），或提供（不太方便/优雅？）std::ostream& stream() { return s_; }- 风格的访问器。
于 2013-07-18T04:37:24.583 回答