我正在尝试构建一个工具来测试我的Internet连接的延迟，更具体地说是网站加载时间。 我想到了将python request模块用于加载部分。
问题是，它没有内置功能来衡量获得完整响应所花费的时间。 为此，我认为我将使用timeit模块。
我不确定的是，如果我像这样运行timeit：
t = timeit.Timer("requests.get('http://www.google.com')", "import requests")
我实际上是在衡量响应到达所花费的时间，还是建立，发送，接收请求等所花费的时间？ 我猜我可能会忽略执行时间，因为我正在测试延迟很长的网络（〜700ms）？
有没有更好的方法以编程方式执行此操作？
我正在构建一个包含两个组件的应用程序-用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"
#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;
}
#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，但仍然无效
由于@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毫秒，没有加速:(
我向Thrift Jira报告了一个问题
这是完全不科学的，但是使用带有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
我想在Python中打开TCP客户端套接字。 我是否必须遍历所有底层BSD create-socket-handle / connect-socket的东西，还是有一种更简单的单行方法？
有什么好的方法可以做到这一点？ 甚至可以干净地做吗？
理想情况下，我想使用数据包头来确定哪个服务器应处理请求。 但是，如果有更简便/更好的方法，请告诉我。
我在Wireshark中应用了一个过滤器，以仅显示传入PC的数据包。 当我将过滤/显示的数据包保存到.csv文件时，实际上我保存了所有数据包（未过滤）。 如何只保存显示/过滤的数据包？
我的脚本有一个小问题，我需要将“ 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`
有人知道该如何解决吗？
我有一个安全扫描，发现它指示我禁用TCP时间戳。 我理解提出此建议的原因：时间戳可用于计算服务器正常运行时间，这对攻击者可能会有所帮助（[http://www.silby.com/eurobsdcon05/eurobsdcon_silbersack标题为“ TCP Timestamps”的详细说明。 pdf）。]
但是，据我了解，TCP时间戳旨在增强TCP性能。 自然地，在成本/收益分析中，性能下降是很大的，甚至可能太大。 我很难理解可能会有多少性能成本。 蜂巢中的任何节点都希望提供帮助？
网络术语中使用什么单位？ 我们在哪里使用它们？
我知道以下内容-但我不确定它们的含义是什么：
可以将它们分配给特定的OSI层吗？ 更复杂吗？
当我在一个Docker主机上为同一Web映像启动两个Docker容器时。
x.x.x.x:5000x.x.x.x:5000映射到Docker主机的不同端口：49156，49156x.x.x.x:5000或49156是否有解决方案可以通过其IP和端口x.x.x.x:5000从docker主机外部访问docker容器而无需端口映射？
不同坞站主机上的所有docker容器都可以直接相互访问。
我在模拟器中安装了Windows 8，并在其上安装了新的WP8 SDK。 我的问题是模拟器无法连接到互联网。 我没有任何代理，甚至禁用了防火墙。 虽然它似乎仍然不起作用。 当我查看“网络连接”部分时，可以看到hyper-v管理器为模拟器创建的新连接，以及创建的自动网桥，但即使在此状态下，网络状态也为“无Internet连接”。
我可以在Hyper-V中手动更改某些属性，还是可以使网络使所有功能正常工作？
更新：我已完成建议的所有操作，包括创建自己的开关并删除所有其他开关。 但是它仍然不起作用。 它不能在电缆上工作，也不能在wifi上工作。 也许我缺少有关如何设置此功能的信息？
WP模拟器每次都不断为我提供连接到Internet的服务。 它总是会删除我已经设置的所有定义，并用它自己的定义替换它。
除了SSH提供的增强身份验证选项之外，SSH和SSL协议的基本工作方式之间是否有区别？
我问，因为我们可以使用SFTP或SSL上的FTP，所以两者都需要身份验证。
我知道您可以在Windows中创建虚拟网络接口（请参见此处），在Linux中使用ip别名也很容易，但是Mac OS X是否存在类似的功能？ 我一直在寻找回送适配器，虚拟接口，但找不到一个好的解决方案。
您可以基于现有接口在网络面板中创建一个新接口，但是它不会充当真正的功能齐全的接口（如果原始接口处于非活动状态，则派生的接口也将处于非活动状态）。
在完全断开连接的情况下工作时，需要这种情况。 即使这样，在VMWare安装中运行服务器时具有网络功能也是有意义的。 即使我在这些虚拟机之一中运行DNS服务器，也可以通过其IP地址访问这些虚拟机，但不能通过其DNS名称访问。 通过配置使用虚拟DNS服务器的接口，我认为我可以测试某些DNS方案。 不幸的是，如果没有一个接口处于非活动状态，则没有接口会解析DNS名称...
我想知道TCP中bind（）的确切功能。 将本地地址“绑定”到套接字是什么意思？ 如果它正在为套接字分配端口号，那么为什么我们不在客户端中使用它呢？ 我知道该端口是由OS在客户端自动分配的，但是我对这一切的工作原理没有了解。
在bind（）之后，我们监听（）。 绑定与listen（）有何关系？ 将listen（）知道bind（）已执行吗？ 如果是这样，bind（）会进行哪些更改以使其已知？ 我的意思是，成功执行返回零将有什么帮助？
我已经经历了很多定义，但是没有什么地方可以得到所有这些详细信息。 因此，如果有人可以向我解释这一点，我将不胜感激。
这个问题已经在这里有了答案：
我知道这些指标不止一个。谢谢。
如果TCP有效载荷在传输过程中损坏，则重新计算的校验和将与传输的校验和不匹配。 很好，到目前为止一切都很好。
如果TCP校验和在传输中损坏，则重新计算的校验和将与现在已损坏的校验和不匹配。 很好，到目前为止一切都很好。
当有效负载和校验和都被破坏并且重新计算的校验和与应有的不同时，恰好匹配现在已损坏的校验和，会发生什么？
我可以看到一个好的校验和算法（以及较低级别的附加校验和），这可能非常非常不可能，但是TCP是否不是100％可靠的？ 如何解决这些误报？
由于迁移到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中实现上传方法的方式
在广播的答案之一（如具有TCP可靠性的UDP）中，用户提到了Spread消息传递API。 我也遇到过一个叫做ØMQ的问题。 我也对MPI有所了解。
所以，我的主要问题是：为什么我要选择一个？ 更具体地说，当有成熟的MPI实现时，为什么选择使用Spread或ØMQ？
选择要启动的Amazon AWS实例类型时，每种类型都有一个属性，即“网络性能”，即“低”，“中等”或“高”。我想知道这到底意味着什么。 如果我选择低，我的Ping会更低吗？ 还是只要没有一次登录就可以了？
我正在发布一款实时多人游戏，所以我对“网络性能”到底是什么感到好奇。 我实际上需要相当低的内存和处理能力，但是具有这些条件的实例通常具有“低”的网络性能。
有没有人体验过不同的网络性能或了解更多信息？
谢谢！
缺少解析ipconfig的输出的方法，有人能做到这一点的100％纯Java方法吗？