Haskell Thrift库在性能方面比C ++慢300倍

我正在构建一个包含两个组件的应用程序-用Haskell编写的服务器和用Qt(C ++)编写的客户端。 我正在节俭地与他们交流,我想知道为什么它这么慢。

我进行了性能测试,这是我的机器上的结果

结果

C++ server and C++ client:

Sending 100 pings                    -    13.37 ms
Transfering 1000000 size vector      -   433.58 ms
Recieved: 3906.25 kB
Transfering 100000 items from server -  1090.19 ms
Transfering 100000 items to server   -   631.98 ms

Haskell server and C++ client:

Sending 100 pings                       3959.97 ms
Transfering 1000000 size vector      - 12481.40 ms
Recieved: 3906.25 kB
Transfering 100000 items from server - 26066.80 ms
Transfering 100000 items to server   -  1805.44 ms

为什么Haskell在测试中这么慢? 如何提高性能?

这些是文件:

档案

性能节俭

namespace hs test
namespace cpp test

struct Item {
    1: optional string    name
    2: optional list<i32> coordinates
}

struct ItemPack {
    1: optional list<Item>     items
    2: optional map<i32, Item> mappers
}


service ItemStore {
    void ping()
    ItemPack getItems(1:string name, 2: i32 count) 
    bool     setItems(1: ItemPack items)

    list<i32> getVector(1: i32 count)
}

主站

{-# LANGUAGE ScopedTypeVariables #-}   
module Main where

import           Data.Int  
import           Data.Maybe (fromJust) 
import qualified Data.Vector as Vector
import qualified Data.HashMap.Strict  as HashMap
import           Network

-- Thrift libraries
import           Thrift.Server

-- Generated Thrift modules
import Performance_Types
import ItemStore_Iface
import ItemStore


i32toi :: Int32 -> Int
i32toi = fromIntegral

itoi32 :: Int -> Int32
itoi32 = fromIntegral

port :: PortNumber
port = 9090

data ItemHandler = ItemHandler

instance ItemStore_Iface ItemHandler where
    ping _                   = return () --putStrLn "ping"
    getItems _ mtname mtsize = do 
        let size = i32toi $ fromJust mtsize
            item i = Item mtname (Just $ Vector.fromList $ map itoi32 [i..100])
            items = map item [0..(size-1)]
            itemsv = Vector.fromList items 
            mappers = zip (map itoi32 [0..(size-1)]) items 
            mappersh = HashMap.fromList mappers
            itemPack = ItemPack (Just itemsv) (Just mappersh)
        putStrLn "getItems"
        return itemPack

    setItems _ _             = do putStrLn "setItems"
                                  return True

    getVector _ mtsize       = do putStrLn "getVector"
                                  let size = i32toi $ fromJust mtsize
                                  return $ Vector.generate size itoi32

main :: IO ()
main = do
    _ <- runBasicServer ItemHandler process port 
    putStrLn "Server stopped"

ItemStore_client.cpp

#include <iostream>
#include <chrono>
#include "gen-cpp/ItemStore.h"

#include <transport/TSocket.h>
#include <transport/TBufferTransports.h>
#include <protocol/TBinaryProtocol.h>

using namespace apache::thrift;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;

using namespace test;
using namespace std;

#define TIME_INIT  std::chrono::_V2::steady_clock::time_point start, stop; \
                   std::chrono::duration<long long int, std::ratio<1ll, 1000000000ll> > duration;
#define TIME_START start = std::chrono::steady_clock::now(); 
#define TIME_END   duration = std::chrono::steady_clock::now() - start; \
                   std::cout << chrono::duration <double, std::milli> (duration).count() << " ms" << std::endl;

int main(int argc, char **argv) {

    boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090));
    boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
    boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));

    ItemStoreClient server(protocol);
    transport->open();

    TIME_INIT

    long pings = 100;
    cout << "Sending " << pings << " pings" << endl;
    TIME_START
    for(auto i = 0 ; i< pings ; ++i)
        server.ping();
    TIME_END


    long vectorSize = 1000000;

    cout << "Transfering " << vectorSize << " size vector" << endl;
    std::vector<int> v;
    TIME_START
    server.getVector(v, vectorSize);
    TIME_END
    cout << "Recieved: " << v.size()*sizeof(int) / 1024.0 << " kB" << endl;


    long itemsSize = 100000;

    cout << "Transfering " << itemsSize << " items from server" << endl;
    ItemPack items;
    TIME_START
    server.getItems(items, "test", itemsSize);
    TIME_END


    cout << "Transfering " << itemsSize << " items to server" << endl;
    TIME_START
    server.setItems(items);
    TIME_END

    transport->close();

    return 0;
}

ItemStore_server.cpp

#include "gen-cpp/ItemStore.h"
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/server/TSimpleServer.h>
#include <thrift/transport/TServerSocket.h>
#include <thrift/transport/TBufferTransports.h>

#include <map>
#include <vector>

using namespace ::apache::thrift;
using namespace ::apache::thrift::protocol;
using namespace ::apache::thrift::transport;
using namespace ::apache::thrift::server;


using namespace test;
using boost::shared_ptr;

class ItemStoreHandler : virtual public ItemStoreIf {
  public:
    ItemStoreHandler() {
    }

    void ping() {
        // printf("ping\n");
    }

    void getItems(ItemPack& _return, const std::string& name, const int32_t count) {

        std::vector <Item> items;
        std::map<int, Item> mappers;

        for(auto i = 0 ; i < count ; ++i){
            std::vector<int> coordinates;
            for(auto c = i ; c< 100 ; ++c)
                coordinates.push_back(c);

            Item item;
            item.__set_name(name);
            item.__set_coordinates(coordinates);

            items.push_back(item);
            mappers[i] = item;
        }

        _return.__set_items(items);
        _return.__set_mappers(mappers);
        printf("getItems\n");
    }

    bool setItems(const ItemPack& items) {
        printf("setItems\n");
        return true;
    }

    void getVector(std::vector<int32_t> & _return, const int32_t count) {
        for(auto i = 0 ; i < count ; ++i)
            _return.push_back(i);
        printf("getVector\n");
    }
};

int main(int argc, char **argv) {
    int port = 9090;
    shared_ptr<ItemStoreHandler> handler(new ItemStoreHandler());
    shared_ptr<TProcessor> processor(new ItemStoreProcessor(handler));
    shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
    shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());

    TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
    server.serve();
    return 0;
}

生成文件

GEN_SRC := gen-cpp/ItemStore.cpp gen-cpp/performance_constants.cpp gen-cpp/performance_types.cpp
GEN_OBJ := $(patsubst %.cpp,%.o, $(GEN_SRC))

THRIFT_DIR := /usr/local/include/thrift
BOOST_DIR := /usr/local/include

INC := -I$(THRIFT_DIR) -I$(BOOST_DIR)

.PHONY: all clean

all:   ItemStore_server ItemStore_client

%.o: %.cpp
    $(CXX) --std=c++11 -Wall -DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H $(INC) -c $< -o $@

ItemStore_server: ItemStore_server.o $(GEN_OBJ) 
    $(CXX) $^ -o $@ -L/usr/local/lib -lthrift -DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H

ItemStore_client: ItemStore_client.o $(GEN_OBJ)
    $(CXX) $^ -o $@ -L/usr/local/lib -lthrift -DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H

clean:
    $(RM) *.o ItemStore_server ItemStore_client

编译并运行

我生成文件(使用此处的thrift 0.9):

$ thrift --gen cpp performance.thrift
$ thrift --gen hs performance.thrift

编译

$ make
$ ghc Main.hs gen-hs/ItemStore_Client.hs gen-hs/ItemStore.hs gen-hs/ItemStore_Iface.hs gen-hs/Performance_Consts.hs gen-hs/Performance_Types.hs -Wall -O2

运行Haskell测试:

$ ./Main& 
$ ./ItemStore_client

运行C ++测试:

$ ./ItemStore_server&
$ ./ItemStore_client

记住在每次测试后都要杀死服务器

更新资料

编辑了getVector方法以使用getItems代替Vector.fromList,但仍然无效

更新2

由于@MdxBhmt的建议,我测试了getItems函数,如下所示:

getItems _ mtname mtsize = do let size = i32toi $! fromJust mtsize
                                  item i = Item mtname (Just $!  Vector.enumFromN (i::Int32) (100- (fromIntegral i)))
                                  itemsv = Vector.map item  $ Vector.enumFromN 0  (size-1)
                                  itemPack = ItemPack (Just itemsv) Nothing 
                              putStrLn "getItems"
                              return itemPack

在我的原始实现的基础上,这是严格的,并且改进了Vector的生成,相对于其替代方法:

getItems _ mtname mtsize = do let size = i32toi $ fromJust mtsize
                                  item i = Item mtname (Just $ Vector.fromList $ map itoi32 [i..100])
                                  items = map item [0..(size-1)]
                                  itemsv = Vector.fromList items 
                                  itemPack = ItemPack (Just itemsv) Nothing
                              putStrLn "getItems"
                              return itemPack

请注意,没有发送HashMap。 第一个版本的时间为12338.2毫秒,第二个版本为11698.7毫秒,没有加速:(

更新3

我向Thrift Jira报告了一个问题

abhinav的Update 4

这是完全不科学的,但是使用带有Thrift 0.9.2的GHC 7.8.3和@MdxBhmt的版本getItems,可以大大减少差异。

C++ server and C++ client:

Sending 100 pings:                     8.56 ms
Transferring 1000000 size vector:      137.97 ms
Recieved:                              3906.25 kB
Transferring 100000 items from server: 467.78 ms
Transferring 100000 items to server:   207.59 ms

Haskell server and C++ client:

Sending 100 pings:                     24.95 ms
Recieved:                              3906.25 kB
Transferring 1000000 size vector:      378.60 ms
Transferring 100000 items from server: 233.74 ms
Transferring 100000 items to server:   913.07 ms

执行了多次执行,每次都重新启动服务器。 结果是可重现的。

请注意,原始问题的源代码(使用@MdxBhmt的getItems实现)将无法原样编译。 必须进行以下更改:

getItems _ mtname mtsize = do let size = i32toi $! fromJust mtsize
                                  item i = Item mtname (Just $!  Vector.enumFromN (i::Int32) (100- (fromIntegral i)))
                                  itemsv = Vector.map item  $ Vector.enumFromN 0  (size-1)
                                  itemPack = ItemPack (Just itemsv) Nothing 
                              putStrLn "getItems"
                              return itemPack

getVector _ mtsize       = do putStrLn "getVector"
                              let size = i32toi $ fromJust mtsize
                              return $ Vector.generate size itoi32
remdezx asked 2020-08-12T08:06:03Z
5个解决方案
27 votes

所有人都指出,罪魁祸首是旧版库,但我将重点介绍您的代码(以及可以帮助您提高速度的地方)

使用简化的代码版本,您可以在其中计算item i

testfunc mtsize =  itemsv
  where size = i32toi $ fromJust mtsize
        item i = Item (Just $ Vector.fromList $ map itoi32 [i..100])
        items = map item [0..(size-1)]
        itemsv = Vector.fromList items 

首先,您在item i中创建了许多中间数据。由于懒惰,那些小的而快速的计算向量在我们可以立即使用它们的时候就变成了延迟的数据。

仔细放置了2个item i,它们表示严格的评估:

 item i = Item (Just $! Vector.fromList $! map itoi32 [i..100])

将使您的运行时间减少25%(对于大小1e5和1e6)。

但是这里还有一个更成问题的模式:您生成一个列表将其转换为向量,而不是直接构建向量。

看最后两行,创建一个列表->映射函数->转换为向量。

好吧,向量与列表非常相似,您可以做类似的事情! 因此,您必须在其上生成一个vector-> vector.map并完成。 不再需要将列表转换为向量,并且映射向量通常比列表快!

因此,您可以摆脱item i并重新编写以下itemsv

  itemsv = Vector.map item  $ Vector.enumFromN 0  (size-1)

item i重新应用相同的逻辑,我们将删除所有列表。

testfunc3 mtsize = itemsv
   where 
      size = i32toi $! fromJust mtsize
      item i = Item (Just $!  Vector.enumFromN (i::Int32) (100- (fromIntegral i)))
      itemsv = Vector.map item  $ Vector.enumFromN 0  (size-1)

与初始运行时相比,减少了50%。

MdxBhmt answered 2020-08-12T08:07:03Z
12 votes

您应该看一下Haskell分析方法,以发现程序使用/分配了哪些资源以及在哪里。

在真实世界中进行Haskell分析的章节是一个很好的起点。

matthias krull answered 2020-08-12T08:07:28Z
12 votes

这与user13251所说的完全一致:Thrift的haskell实现意味着大量的小读取。

EG:在Thrift,Protocol,Binary中

readI32 p = do
    bs <- tReadAll (getTransport p) 4
    return $ Data.Binary.decode bs

让我们忽略其他奇数位,现在只关注它。 这就是说:“要读取32位int:从传输中读取4个字节,然后对该延迟字节串进行解码。”

传输方法使用惰性字节串hGet精确读取4个字节。 hGet将执行以下操作:分配4个字节的缓冲区,然后使用hGetBuf填充此缓冲区。 hGetBuf可能正在使用内部缓冲区,具体取决于如何初始化Handle。

因此可能会有一些缓冲。 即使这样,这也意味着Thrift for haskell正在对每个整数单独执行读/解码周期。 每次分配一个小的内存缓冲区。 哎哟!

如果没有修改Thrift库以执行更大的字节字符串读取,我真的看不到解决此问题的方法。

在节俭的实现中还有其他怪异之处:将类用于方法结构。 尽管它们看起来很相似,并且可以像方法的结构一样工作,有时甚至可以实现为方法的结构:但不应将它们视作这样。 请参见“现有类型类”反模式:

  • [HTTP://Luke Palmer.WordPress.com/2010/01/24/Haskell-anti pattern-existential-type class/]

测试实现的一个奇怪的部分:

  • 生成一个Int数组只是为了立即将它们更改为Int32,而仅是立即打包到一个Int32s向量中。 立即产生载体将是足够且更快的。

但是,我怀疑这不是性能问题的主要来源。

CoreyOConnor answered 2020-08-12T08:08:33Z
10 votes

我看不到Haskell服务器中对缓冲的任何引用。 在C ++中,如果不进行缓冲,则会对每个vector / list元素产生一个系统调用。 我怀疑Haskell服务器中正在发生同样的事情。

我没有直接在Haskell中看到缓冲传输。 作为实验,您可能想同时更改客户端和服务器以使用成帧传输。 Haskell确实有框架传输,并且已缓冲。 请注意,这将改变导线布局。

作为一个单独的实验,您可能想要关闭C ++的缓冲,并查看性能数字是否可比。

user13251 answered 2020-08-12T08:09:03Z
6 votes

您正在使用的基本节俭服务器的Haskell实现在内部使用线程,但是您没有将其编译为使用多个内核。

要使用多个内核再次进行测试,请更改用于编译Haskell程序的命令行,使其包含-rtsopts-threaded,然后运行最终二进制文件(如./Main -N4 &),其中4是要使用的内核数。

kvanberendonck answered 2020-08-12T08:09:30Z
translate from https://stackoverflow.com:/questions/19512952/haskell-thrift-library-300x-slower-than-c-in-performance-test