C Solaris 10上的Unix域套接字速度比Linux慢100倍？

我正在为一个项目测试Linux和Solaris上的本地套接字性能。出于某种原因，我无法发现，Solaris上的性能比Linux上差大约100倍。在Linux中，打开一个套接字，每次交换一条非常短（2个字符）的消息，然后关闭它需要大约10秒的时间。在Solaris上，同样的事情需要大约1000个US

安装的是Solaris 10 developer vm in Virtual Box和Linux，两者都位于同一虚拟机中，并且直接位于同一硬件上（没有区别）

这是Solaris的已知问题吗？有什么办法解决这个问题吗？我无法使用本地网络连接，原因是我无法进入这里

下面是客户端和服务器的代码。使用“cc-fast-m64-lrt-lsocket-lnsl-oserver.c”和客户机的等效文件进行编译。与Solaris 10一起交付的Gcc 3.4.3给出了类似的结果。此代码已被减少，例如超时已被删除，因此错误处理最小

服务器c:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <time.h>
#include <string.h>
#include <unistd.h>

#define DIRECTORY "sub/"
#define FULL_PATH "sub/c_socket"
#define MAX_COMMAND_LEN 8192
#define PERMISSIONS 0700

void on_error(int err, char * msg) {  // simple convenient error handler
  if (err == -1) {                    // Tests whether 'err' is -1 and
    perror(msg);                      // prints error and msg if so.
    exit(-1);
  }
}

int main() {
  struct sockaddr_un addr;
  int srv_fd, inst_fd;
  int inst_adr_size;
  char c;
  int ret;
  char readbuf[MAX_COMMAND_LEN];
  int num_read;
  fd_set rfds;
  int fail;
  int i;

  // make address
  memset(&addr, 0, sizeof(addr));  // clear out addr
  addr.sun_family = AF_UNIX;
  strncpy(addr.sun_path, FULL_PATH, sizeof(addr.sun_path));

  // Remove old pseudo file if present
  ret = unlink(FULL_PATH);
  if (ret == -1 && errno != ENOENT) {
    on_error(ret,"\nRemoving old socket file\n");
  }
  // Remove old directory if present
  ret = rmdir(DIRECTORY);
  if (ret == -1 && errno != ENOENT) {
    on_error(ret, "\nRemoving old socket directory\n");
  }

  // Re-create new directory with appropriate permissonsm
  ret = mkdir(DIRECTORY, PERMISSIONS);
  on_error(ret,"\nCreating directoroy for socket file\n");

  // create server listening socket
  srv_fd = socket(AF_UNIX, SOCK_STREAM, 0);
  on_error(srv_fd, "\nSocket creation:\n");

  // bind server listening socket to address
  ret = bind(srv_fd, (struct sockaddr *) &addr, sizeof(addr));
  on_error(ret, "\nSocket binding:\n");

  // set file permissions for socket file (somewhat redundant)
  ret = chmod(FULL_PATH, PERMISSIONS);
  on_error(ret, "\nSetting socket file permissions\n");

  // set socket listening and queue length
  ret = listen(srv_fd, 10);
  on_error(ret, "\nSet socket to listen:\n");
  while(1) {
    // accept requests
    inst_fd = accept(srv_fd, NULL, NULL);
    on_error(inst_fd, "\n accepting connection:\n");

    // prepare to use select on inst_fd
    FD_ZERO(&rfds);
    FD_SET(inst_fd, &rfds);

    // now interact with the client on the instance socket.
    while(1) {
      num_read = 0;

      while (1) {
        // read a line terminated by '\n'
        ret = select(inst_fd + 1, &rfds, NULL, NULL, NULL);
        on_error(ret, "\nSelect on socket\n");

        if (ret == 1) {
          // we can read something
          ret = recv(inst_fd, readbuf+num_read, MAX_COMMAND_LEN-num_read, 0
          on_error(ret, "\nrecv:\n");

          if (ret == 0) {
            break; // we have EOF
          }

          num_read += ret;
          if (readbuf[num_read - 1] == '\n') {
            break;
          }
        }
      } /* reading one input line done */

      if (num_read == 0) break; // EOF propagated

      // process command: Just send 2 chars back
      ret = send(inst_fd, "n\n", 2, 0);
    }
    close(inst_fd);               // clean up
  }
  // runs forever...
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义目录“sub/”
#定义完整路径“子/c\U套接字”
#定义最大命令长度8192
#定义权限0700
void on_error（int err，char*msg）{//简单方便的错误处理程序
if（err==-1）{//测试“err”是否为-1，以及
perror（msg）；//如果是，则打印错误和消息。
出口（-1）；
}
}
int main（）{
结构sockaddr_un addr；
内部srv_fd，仪表fd；
内装adr尺寸；
字符c；
int ret；
char readbuf[MAX_COMMAND_LEN]；
int num_read；
fd_集rfds；
int失败；
int i；
//地址
memset（&addr，0，sizeof（addr））；//清除addr
addr.sun_family=AF_UNIX；
strncpy（addr.sun_路径、FULL_路径、sizeof（addr.sun_路径））；
//删除旧的伪文件（如果存在）
ret=取消链接（完整路径）；
if（ret==-1&&errno！=enoint）{
出现错误（ret，“\n正在删除旧套接字文件\n”）；
}
//删除旧目录（如果存在）
ret=rmdir（目录）；
if（ret==-1&&errno！=enoint）{
出现错误（ret，“\n正在删除旧套接字目录\n”）；
}
//使用适当的权限重新创建新目录
ret=mkdir（目录、权限）；
错误（ret，“\n正在为套接字文件\n创建目录”）；
//创建服务器侦听套接字
srv_fd=socket（AF_UNIX，SOCK_流，0）；
on_错误（srv_fd，“\n创建套接字：\n”）；
//将服务器侦听套接字绑定到地址
ret=bind（srv_fd，（struct sockaddr*）&addr，sizeof（addr））；
on_错误（ret，“\n套接字绑定：\n”）；
//为套接字文件设置文件权限（有些冗余）
ret=chmod（完整路径、权限）；
on_错误（ret，“\n设置套接字文件权限\n”）；
//设置套接字侦听和队列长度
ret=监听（srv_fd，10）；
在\u错误（ret，“\n设置要侦听的套接字：\n”）；
而(1){
//接受请求
inst_fd=接受（srv_fd，NULL，NULL）；
on_错误（inst_fd，“\n接受连接：\n”）；
//准备使用仪表上的选择功能
FD_ZERO（和RFD）；
FD_集（安装FD和RFD）；
//现在在实例套接字上与客户机交互。
而(1){
num_read=0；
而(1){
//读取以“\n”结尾的行
ret=select（inst_fd+1，&rfds，NULL，NULL，NULL）；
on_错误（ret，“\n在套接字上选择\n”）；
如果（ret==1）{
//我们可以读一些东西
ret=recv（指令fd、readbuf+num_read、MAX_命令LEN-num_read，0
错误（ret，“\nrecv:\n”）；
如果（ret==0）{
break；//我们有EOF
}
num_read+=ret；
if（readbuf[num\u read-1]=='\n'）{
打破
}
}
}/*读取一个输入行完成*/
如果（num_read==0）中断；//已传播EOF
//进程命令：只需返回2个字符
ret=发送（inst_fd，“n\n”，2，0）；
}
关闭（安装fd）；//清理
}
//永远运行。。。
}

客户c：

#include <stdio.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define RCVBUFSIZE 8192   /* Size of receive buffer */
#define FULL_PATH "sub/c_socket"
#define CYCLES 100000

void on_error(int err, char * msg) {  // more convenient error output
  if (err == -1) {                    // Tests whether 'err' is -1 and
    perror(msg);                      // prints error and msg if so.
    exit(-1);
  }
}

int main(int argc, char *argv[]) {
  int client_fd;
  struct sockaddr_un addr;
  char readbuf[RCVBUFSIZE+1];
  int num_read;
  int ret;
  int count;
  fd_set rfds;

  char * msg = "N\n";

  // make address
  memset(&addr, 0, sizeof(addr));  // clear out addr
  addr.sun_family = AF_UNIX;
  strncpy(addr.sun_path, FULL_PATH, sizeof(addr.sun_path));

  for(count = 0; count < CYCLES; count++) {
    // create socket
    client_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    on_error(client_fd, "socket() failed");

    // prepare to use select on inst_fd
    FD_ZERO(&rfds);
    FD_SET(client_fd, &rfds);

    // connect
    ret = connect(client_fd, (struct sockaddr *) &addr, sizeof(addr));
    on_error(ret, "connect() failed");

    // send msg to server
    ret = send(client_fd, msg, 2, 0);
    if (ret != 2) {
      on_error(-1, "\nnot all bytes sent\n");
    }

    num_read = 0;
    // read until we have a '\n'
    while (1) {
      ret = select(client_fd + 1, &rfds, NULL, NULL, NULL);
      on_error(ret, "\nSelect on socket\n");

      if (ret == 1) {
        // we can read something
        ret = recv(client_fd, readbuf + num_read, RCVBUFSIZE - num_read, 0)
        on_error(ret, "\nrecv:\n");
        num_read += ret;
        if (readbuf[num_read - 1] == '\n') break;
      }
    }
    if (num_read == 0) break;
    close(client_fd);
  }
  return(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义接收缓冲区的RCVBUFSIZE 8192/*大小*/
#定义完整路径“子/c\U套接字”
#定义周期100000
void on_error（int err，char*msg）{//更方便的错误输出
if（err==-1）{//测试“err”是否为-1，以及
perror（msg）；//如果是，则打印错误和消息。
出口（-1）；
}
}
int main（int argc，char*argv[]）{
国际客户联合会；
结构sockaddr_un addr；
char readbuf[RCVBUFSIZE+1]；
int num_read；
int ret；
整数计数；
fd_集rfds；
char*msg=“N\N”；
//地址
memset（&addr，0，sizeof（addr））；//清除addr
addr.sun_family=AF_UNIX；
strncpy（addr.sun_路径、FULL_路径、sizeof（addr.sun_路径））；
用于（计数=0；计数<周期；计数++）{
//创建套接字
client_fd=socket（PF_UNIX，SOCK_流，0）；
on_错误（客户端_fd，“套接字（）失败”）；
//准备使用仪表上的选择功能
FD_ZERO（和RFD）；
FD_集（客户_FD和RFD）；
//连接
ret=connect（client_fd，（struct sockaddr*）&addr，sizeof（addr））；
on_错误（ret，“connect（）失败”）；
//向服务器发送消息
ret=发送（客户机，消息，2，0）；
如果（ret！=2）{
在_错误（-1，“\n未发送所有字节\n”）；
}
num_read=0；
//阅读直到我们有一个“\n”
而(1){
ret=select（客户机\u fd+1，&rfds，NULL，NULL，NULL）；
on_错误（ret，“\n在套接字上选择\n”）；
如果（ret==1）{
//我们可以读一些东西
ret=recv（客户端\u fd，readbuf+num\u read，RCVBUFSIZE-num\u read，0）
错误（ret，“\nrecv:\n”）；
num_read+=ret；
if（readbuf[num_read-1]=='\n'）中断；
}
}
如果（num_read==0）中断；
关闭（客户_fd）；
}
返回（0）；
}

我在研究套接字并尝试编写ftp服务器时遇到了类似的问题：由于转换为ascii的过程中出现了错误，我最终只能一次编写一个字节的文件，但在linux上可以，而