javascript

git

python

java

git-remote

github

django

c#

reactjs

c++

validation

email-validation

undefined

scrum

kubernetes

ruby-on-rails

.net

.net-framework-version

operators

git-fetch

网络-使用Python请求衡量网站加载时间

我正在尝试构建一个工具来测试我的Internet连接的延迟,更具体地说是网站加载时间。 我想到了将python request模块用于加载部分。

问题是,它没有内置功能来衡量获得完整响应所花费的时间。 为此,我认为我将使用timeit模块。

我不确定的是,如果我像这样运行timeit:

t = timeit.Timer("requests.get('http://www.google.com')", "import requests")

我实际上是在衡量响应到达所花费的时间,还是建立,发送,接收请求等所花费的时间? 我猜我可能会忽略执行时间,因为我正在测试延迟很长的网络(〜700ms)?

有没有更好的方法以编程方式执行此操作?

trans by 2020-08-12T10:06:29Z

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
trans by 2020-08-12T08:06:03Z

网络-在Python中打开套接字的最佳方法

我想在Python中打开TCP客户端套接字。 我是否必须遍历所有底层BSD create-socket-handle / connect-socket的东西,还是有一种更简单的单行方法?

trans by 2020-08-12T05:52:53Z

Windows 2003上的Apache和IIS并排(都监听端口80)

有什么好的方法可以做到这一点? 甚至可以干净地做吗?

理想情况下,我想使用数据包头来确定哪个服务器应处理请求。 但是,如果有更简便/更好的方法,请告诉我。

trans by 2020-08-09T06:27:47Z

网络-将显示/过滤的数据包保存在Wireshark中

我在Wireshark中应用了一个过滤器,以仅显示传入PC的数据包。 当我将过滤/显示的数据包保存到.csv文件时,实际上我保存了所有数据包(未过滤)。 如何只保存显示/过滤的数据包?

trans by 2020-08-05T06:38:58Z

网络-从IP字符串转换为整数,然后在Python中反向转换

我的脚本有一个小问题,我需要将“ xxx.xxx.xxx.xxx”形式的ip转换为整数表示形式,然后从此形式返回。

def iptoint(ip):
    return int(socket.inet_aton(ip).encode('hex'),16)

def inttoip(ip):
    return socket.inet_ntoa(hex(ip)[2:].decode('hex'))


In [65]: inttoip(iptoint('192.168.1.1'))
Out[65]: '192.168.1.1'

In [66]: inttoip(iptoint('4.1.75.131'))
---------------------------------------------------------------------------
error                                     Traceback (most recent call last)

/home/thc/<ipython console> in <module>()

/home/thc/<ipython console> in inttoip(ip)

error: packed IP wrong length for inet_ntoa`

有人知道该如何解决吗?

trans by 2020-08-03T12:39:25Z

网络-TCP时间戳赋予了什么好处?

我有一个安全扫描,发现它指示我禁用TCP时间戳。 我理解提出此建议的原因:时间戳可用于计算服务器正常运行时间,这对攻击者可能会有所帮助([http://www.silby.com/eurobsdcon05/eurobsdcon_silbersack标题为“ TCP Timestamps”的详细说明。 pdf)。]

但是,据我了解,TCP时间戳旨在增强TCP性能。 自然地,在成本/收益分析中,性能下降是很大的,甚至可能太大。 我很难理解可能会有多少性能成本。 蜂巢中的任何节点都希望提供帮助?

trans by 2020-08-03T01:03:49Z

网络-网络单元的定义:片段,段,分组,帧,数据报

网络术语中使用什么单位? 我们在哪里使用它们?

我知道以下内容-但我不确定它们的含义是什么:

  • 分段
  • 分割
  • 数据报

可以将它们分配给特定的OSI层吗? 更复杂吗?

trans by 2020-08-02T11:02:14Z

网络-如何在没有端口映射的情况下将Docker容器的ip和端口暴露给外部docker主机?

当我在一个Docker主机上为同一Web映像启动两个Docker容器时。

  • 两个docker容器在同一端口上侦听x.x.x.x:5000
  • 将两个容器的端口x.x.x.x:5000映射到Docker主机的不同端口:4915649156
  • 从外部docker主机访问两个容器需要通过访问docker主机ip和端口x.x.x.x:500049156

是否有解决方案可以通过其IP和端口x.x.x.x:5000从docker主机外部访问docker容器而无需端口映射?

不同坞站主机上的所有docker容器都可以直接相互访问。

trans by 2020-07-26T09:14:21Z

网络-Windows Phone 8模拟器无法连接到实习生

我在模拟器中安装了Windows 8,并在其上安装了新的WP8 SDK。 我的问题是模拟器无法连接到互联网。 我没有任何代理,甚至禁用了防火墙。 虽然它似乎仍然不起作用。 当我查看“网络连接”部分时,可以看到hyper-v管理器为模拟器创建的新连接,以及创建的自动网桥,但即使在此状态下,网络状态也为“无Internet连接”。

我可以在Hyper-V中手动更改某些属性,还是可以使网络使所有功能正常工作?

更新:我已完成建议的所有操作,包括创建自己的开关并删除所有其他开关。 但是它仍然不起作用。 它不能在电缆上工作,也不能在wifi上工作。 也许我缺少有关如何设置此功能的信息?

WP模拟器每次都不断为我提供连接到Internet的服务。 它总是会删除我已经设置的所有定义,并用它自己的定义替换它。

trans by 2020-07-24T14:42:29Z

网络-SSH和SSL之间的差异,尤其是在“ SFTP”与“基于SSL的FTP”方面

除了SSH提供的增强身份验证选项之外,SSH和SSL协议的基本工作方式之间是否有区别?

我问,因为我们可以使用SFTP或SSL上的FTP,所以两者都需要身份验证。

trans by 2020-07-23T16:33:28Z

macos-Mac OS X中的虚拟网络接口

我知道您可以在Windows中创建虚拟网络接口(请参见此处),在Linux中使用ip别名也很容易,但是Mac OS X是否存在类似的功能? 我一直在寻找回送适配器,虚拟接口,但找不到一个好的解决方案。

您可以基于现有接口在网络面板中创建一个新接口,但是它不会充当真正的功能齐全的接口(如果原始接口处于非活动状态,则派生的接口也将处于非活动状态)。

在完全断开连接的情况下工作时,需要这种情况。 即使这样,在VMWare安装中运行服务器时具有网络功能也是有意义的。 即使我在这些虚拟机之一中运行DNS服务器,也可以通过其IP地址访问这些虚拟机,但不能通过其DNS名称访问。 通过配置使用虚拟DNS服务器的接口,我认为我可以测试某些DNS方案。 不幸的是,如果没有一个接口处于非活动状态,则没有接口会解析DNS名称...

trans by 2020-07-22T17:47:42Z

套接字-为什么在TCP中使用bind()? 为什么只在服务器端而不在客户端使用?

我想知道TCP中bind()的确切功能。 将本地地址“绑定”到套接字是什么意思? 如果它正在为套接字分配端口号,那么为什么我们不在客户端中使用它呢? 我知道该端口是由OS在客户端自动分配的,但是我对这一切的工作原理没有了解。

在bind()之后,我们监听()。 绑定与listen()有何关系? 将listen()知道bind()已执行吗? 如果是这样,bind()会进行哪些更改以使其已知? 我的意思是,成功执行返回零将有什么帮助?

我已经经历了很多定义,但是没有什么地方可以得到所有这些详细信息。 因此,如果有人可以向我解释这一点,我将不胜感激。

trans by 2020-07-22T00:04:58Z

swift-如何在iOS状态栏中打开网络指示灯?

这个问题已经在这里有了答案:

  • 目标C,如何使活动视图显示在顶部通知菜单上 3个答案

我知道这些指标不止一个。谢谢。

trans by 2020-07-21T19:35:49Z

网络-TCP校验和是否无法检测到错误? 如果是,该如何处理?

如果TCP有效载荷在传输过程中损坏,则重新计算的校验和将与传输的校验和不匹配。 很好,到目前为止一切都很好。

如果TCP校验和在传输中损坏,则重新计算的校验和将与现在已损坏的校验和不匹配。 很好,到目前为止一切都很好。

当有效负载和校验和都被破坏并且重新计算的校验和与应有的不同时,恰好匹配现在已损坏的校验和,会发生什么?

我可以看到一个好的校验和算法(以及较低级别的附加校验和),这可能非常非常不可能,但是TCP是否不是100%可靠的? 如何解决这些误报?

trans by 2020-07-19T02:57:40Z

ios-Swift 3 Alamofire分段上传

由于迁移到Swift 3,我发现很难编译使用Alamofire的项目。

上载multipartFormData时发生问题:

Alamofire.upload(.POST, URL, headers: headers, multipartFormData: {
        multipartFormData in
.
.
. 
}) 

对成员'upload(_:to:method:headers :)的含糊引用

任何帮助,不胜感激,在此先感谢!

解决:

 Alamofire.upload(multipartFormData: { (multipartFormData) in

        multipartFormData.append(fileData, withName: "file_pack", fileName: "file_pack", mimeType: "text/plain")


        for (key, value) in self.parameters {
            multipartFormData.append(value.data(using: String.Encoding.utf8)!, withName: key)
        }
        }, with: URL2, encodingCompletion: { (result) in

            switch result {
            case .success(let upload, _, _):

                upload.responseJSON { response in
                    self.delegate?.showSuccessAlert()
                    print(response.request)  // original URL request
                    print(response.response) // URL response
                    print(response.data)     // server data
                    print(response.result)   // result of response serialization
                    //                        self.showSuccesAlert()
                    self.removeImage("frame", fileExtension: "txt")
                    if let JSON = response.result.value {
                        print("JSON: \(JSON)")
                    }
                }

            case .failure(let encodingError):
                self.delegate?.showFailAlert()
                print(encodingError)
            }

    })

这就是应该在Swift 3中实现上传方法的方式

trans by 2020-07-14T00:57:16Z

网络-吞吐量和带宽有何不同?

通道的吞吐量是实际通过通道移动的数据量的度量。 为什么它大大小于通道的带宽?

trans by 2020-07-13T10:28:01Z

api-传播vs MPI vs zeromq?

在广播的答案之一(如具有TCP可靠性的UDP)中,用户提到了Spread消息传递API。 我也遇到过一个叫做ØMQ的问题。 我也对MPI有所了解。

所以,我的主要问题是:为什么我要选择一个? 更具体地说,当有成熟的MPI实现时,为什么选择使用Spread或ØMQ?

trans by 2020-07-11T20:05:32Z

网络-亚马逊AWS的“网络性能”是什么意思?

选择要启动的Amazon AWS实例类型时,每种类型都有一个属性,即“网络性能”,即“低”,“中等”或“高”。我想知道这到底意味着什么。 如果我选择低,我的Ping会更低吗? 还是只要没有一次登录就可以了?

我正在发布一款实时多人游戏,所以我对“网络性能”到底是什么感到好奇。 我实际上需要相当低的内存和处理能力,但是具有这些条件的实例通常具有“低”的网络性能。

有没有人体验过不同的网络性能或了解更多信息?

谢谢!

trans by 2020-07-10T00:24:13Z

网络-如何通过Java枚举所有已启用的NIC卡的IP地址?

缺少解析ipconfig的输出的方法,有人能做到这一点的100%纯Java方法吗?

trans by 2020-07-09T18:16:07Z

1 2 3 4 5 6 7 8 下一页 共8页