open-courses
  • 公开课笔记
  • CMU 15-445/645 Database Systems
    • Relational Data Model
    • Advanced SQL
    • Database Storage
    • Buffer Pools
    • Hash Tables
    • Tree Indexes
    • Index Concurrency Control
    • Query Processing
    • Sorting&Aggregations
    • Join Algorithms
    • Query Optimization
    • Parallel Execution
    • Embedded Database Logic
    • Concurrency Control Theory
    • Two Phase Locking
    • Timestamp Ordering Concurrency Control
    • Multi-Version Concurrency Control
    • Logging Schemes
    • Database Recovery
    • Introduction to Distributed Databases
    • Distributed OLTP Databases
    • Distributed OLAP Databases
  • UCB - CS162
    • OS intro
    • Introduction to the Process
    • Processes, Fork, I/O, Files
    • I/O Continued, Sockets, Networking
    • Concurrency: Processes & Threads
    • Cooperating Threads, Synchronization
    • Semaphores, Condition Variables, Readers/Writers
    • Scheduling
    • Resource Contention & Deadlock
    • Address Translation, Caching
    • File System (18,19,20)
    • Distributed Systems, Networking, TCP/IP, RPC (21,22)
    • Distributed Storage, Key-Value Stores, Security (23)
    • Security & Cloud Computing (24)
    • Topic: Ensuring Data Reaches Disk
  • MIT - 6.006
    • Sequence and Set Interface
    • Data Structure for Dynamic Sequence Interface
    • Computation Complexity
    • Algorithms and Computation
    • Structure Of Computation
    • Graph & Search
    • Tree & Search
    • Weighted Shortest Paths
    • String Matching, Karp-Rabin
    • Priority Queue Interface & Implementation
    • Dictionary Problem & Implementation
    • Sorting
    • Dynamic Programming
    • Backtracking
    • Self-Balancing Tree
  • MIT - 6.824
    • 2PC & 3PC
    • Introduction and MapReduce
    • RPC and Threads
    • Primary/Backup Replication
    • Lab: Primary/Backup Key/Value Service
    • Google File System (GFS)
    • Raft
    • Lab: Raft - Leader Election
    • Lab: Raft - Log Replication
  • Stanford-CS107
    • 原始数据类型及相互转化
    • 指鹿为马
    • 泛型函数
    • 泛型栈
    • 运行时内存结构
    • 从 C 到汇编
    • 函数的活动记录
    • C 与 C++ 代码生成
    • 编译的预处理过程
    • 编译的链接过程
    • 函数的活动记录续、并发
    • 从顺序到并发和并行
    • 信号量与多线程 1
    • 信号量与多线程 2
    • 复杂多线程问题
    • 函数式编程 - Scheme 1
    • 函数式编程 - Scheme 2
    • 函数式编程 - Scheme 3
    • 函数式编程 - Scheme 4
    • 函数式编程 - Scheme 5
    • Python 基础
  • MIT - 6.001 - SICP
    • 什么是程序
    • 程序抽象
    • 替代模型
    • 时间/空间复杂度
    • 数据抽象
    • 高阶函数
    • Symbol
    • 数据驱动编程与防御式编程
    • 数据抽象中的效率与可读性
    • 数据修改
    • 环境模型
    • 面向对象-消息传递
    • 面向对象 - Scheme 实现
    • 构建 Scheme 解释器
    • Eval-Apply Loop
    • Normal Order (Lazy) Evaluation
    • 通用机
    • 寄存器机器
    • 子程序、栈与递归
    • 在寄存器机器中执行
    • 内存管理
  • MIT - 6.046
    • Randomized Algorithms
    • Skip Lists
  • System Design
    • Twitter
    • Cache Consistency & Coherence
  • DDIA 笔记
    • Replication
    • Transactions
    • The Trouble with Distributed Systems
    • Consistency & Consensus
  • Papers We Love
    • Consistent Hashing and Random Trees (1997)
    • Dynamic Hash Tables (1988)
    • LFU Implementation With O(1) Complexity (2010)
    • Time, Clocks, and the Ordering of Events in a Distributed System (1978)
    • Dapper, a Large-Scale Distributed Systems Tracing Infrastructure (2010)
    • Gorilla: A Fast, Scalable, In-Memory Time Series Database (2015)
  • Release It 笔记
    • Anti-patterns & Patterns in Microservice Architecture
  • Database Design
    • Log Structured Merge (LSM) Tree & Usages in KV Stores
    • Prometheus
Powered by GitBook
On this page
  • Communication Between Processes
  • Sockets
  • OS Basics 小结
  1. UCB - CS162

I/O Continued, Sockets, Networking

进程间通信

PreviousProcesses, Fork, I/O, FilesNextConcurrency: Processes & Threads

Last updated 6 years ago

Communication Between Processes

UNIX 的一大 mental model 就是将进程间的通信看作是文件读写的过程,如下图所示:

文件内容的生产者、消费者可以是不同时间运行的不同的进程;有时候我们只希望生产、消费一次,仍然可以使用文件读写作为 mental model,但在这种情况下,queue 的 enqueue、dequeue 更适合这种情形。

如果是通过网络连接的不同进程呢?在上图中间加一朵云即可:

这就是 Client/Server 模型:

  • 假设 Client, Server 之间存在两个文件,其中一个文件叫上行文件,Client 写,Server 读;另一个文件叫下行文件,Client 读,Server 写

  • Client 将请求写入上行文件,然后进入等待状态

  • Server 从上行文件中读取请求信息,处理请求后,将响应写入下行文件中

  • 下行文件接受到数据后,Client 被唤醒,读取响应结果

Sockets

像上述这种两个进程间可双向交流,每条信息都只生产一次、被消费一次的情形,就可以被抽象成 connection,而 connection 的两端就是 socket。sockets 之间的连接不一定通过网络,也可以是本地机器上的两个进程,前者成为 network socket,后者成为 UNIX socket。在 sockets 之间,数据读写的接口如文件读写一般,而它们之间的介质则是透明的。

利用 sockets 开发的 Client/Server 示例如下:

client.c
void client(int sockfd) {
  int n;
  char sndbuf[MAXIN]; 
  char rcvbuf[MAXOUT];
  getreq(sndbuf, MAXIN);
  while (strlen(sndbuf) > 0) {
    write(sockfd, sndbuf, strlen(sndbuf)); /* send */
    memset(rcvbuf, 0, MAXOUT);             /* clear */
    n = read(sockfd, rcvbuf, MAXOUT-1);    /* receive */
    write(STDOUT_FILENO, rcvbuf, n);       /* echo */
    getreq(sndbuf, MAXIN);
  }
}

char *getreq(char *inbuf, int len) {
  /* Get request char stream */
  printf("REQ: ");
  memset(inbuf, 0, len);
  return fgets(inbuf, len, stdin);
}
server.c
void server(int consockfd) {
  char reqbuf[MAXREQ];
  int n;
  while (1) {
    memset(reqbuf, 0, MAXREQ);
    n = read(consockfd, reqbuf, MAXREQ-1); /* Recv */
    if (n <= 0) return;
    n = write(STDOUT_FILENO, reqbuf, strlen(reqbuf));
    n = write(consockfd, reqbuf, strlen(reqbuf)); /* echo */
  }
}

Socket creation and connection

创建 socket 以及和其它 socket 的 connection 要比创建文件及读写文件更复杂一些。文件系统提供了:

  • structured namespace:便于组织文件

  • open, read, write, close 等基本接口

  • 文件本身与进程之间相互独立

那么对于 network socket 来说,它的 structured namespace 是:

  • Hostname

  • IP address

  • Port number

Socket setup over TCP/IP

本节开头处提出的 Client/Server 模型中,Server 一次只能处理一个连接请求,等待连接断开后才可以处理下一个连接,我们可以让 server 每接收到新的连接请求就 fork 新的 process,创建新的 socket,并发地处理连接请求,提高吞吐量,示意图如下:

从图中可以看出,1 个 connection 至少由 2 个 sockets 组成,事实上,connection 由一个 5 元组定义:

[ Client Addr, Client Port, Server Addr, Server Port, Protocol ]

通常 Client Port 被随机赋值,而 Server Port 通常在固定的范围中(0-1023),如:

  • 80: web

  • 443: secure web

  • 25: sendmail

而 Protocol 为 tcp, udp 等传输层协议。

我们先回顾一下基本版的 C/S 模型

但在该版本中,连接处理以及请求处理逻辑与 server 的建立连接、关闭连接等逻辑处在同一个空间中,没有隔离保护,因此更好的方法是在建立新连接时 fork child process,由 child process 负责处理相关逻辑,parent process 等待 child process 搞定后再处理新的连接请求,如下图所示:

但这样并没有利用到多核处理器并行带来的好处,我们可以将上图中的 "Wait for child“ 去除,就得到了并行版本的 Client/Server 模型:

典型的 Server 逻辑如下所示:

while (1) {
  listen(lstnsockfd, MAXQUEUE)
  consockfd = accept(lstnsockfd, (struct sockaddr *) &cli_addr, &client);
  
  cpid = fork();                    /* new process for connection */
  if (cpid > 0) {                   /* parent process */
    close(consockfd); 
  } else if (cpid == 0) {           /* child process */
    close(lstnsockfd);              /* let go of listen socket */
    server(consockfd);
    close(consockfd);
    exit(EXIT_SUCCESS);             /* exit child normally */
  }
}
close(lstnsockfd);

OS Basics 小结

至此,我们介绍了 OS 的一些基本概念:

  • Processes

  • Address Space

  • Protection

  • Dual Mode

  • Interrupt handlers (including syscall and trap)

  • File System

  • Key Layers

    • OS Lib

    • Syscall

    • Subsystem

    • Driver

  • Process control

    • fork

    • wait

    • signal

    • exec

  • Communication through sockets

  • Client-Server Protocol