# Reshape the training and test examples 
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # The "-1" makes reshape flatten the remaining dimensions
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T

# Standardize data to have feature values between 0 and 1.
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.

print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))

def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009
    """
    Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
    
    Arguments:
    X -- data, numpy array of shape (number of examples, num_px * num_px * 3)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
    learning_rate -- learning rate of the gradient descent update rule
    num_iterations -- number of iterations of the optimization loop
    print_cost -- if True, it prints the cost every 100 steps
    
    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """

    np.random.seed(1)
    costs = []                         # keep track of cost
    
    # Parameters initialization.
    ### START CODE HERE ###
    parameters = initialize_parameters_deep(layers_dims)
    ### END CODE HERE ###
    
    # Loop (gradient descent)
    for i in range(0, num_iterations):

        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
        ### START CODE HERE ### (≈ 1 line of code)
        AL, caches = L_model_forward(X, parameters)
        ### END CODE HERE ###
        
        # Compute cost.
        ### START CODE HERE ### (≈ 1 line of code)
        cost = compute_cost(AL, Y)
        ### END CODE HERE ###
    
        # Backward propagation.
        ### START CODE HERE ### (≈ 1 line of code)
        grads = L_model_backward(AL, Y, caches)
        ### END CODE HERE ###
 
        # Update parameters.
        ### START CODE HERE ### (≈ 1 line of code)
        parameters = update_parameters(parameters, grads, learning_rate=learning_rate)
        ### END CODE HERE ###
                
        # Print the cost every 100 training example
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))
        if print_cost and i % 100 == 0:
            costs.append(cost)
            
    # plot the cost
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    
    return parameters

代码如下


def initialize_parameters_deep(layer_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the dimensions of each layer in our network
    
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
                    bl -- bias vector of shape (layer_dims[l], 1)
    """
    
    np.random.seed(3)
    parameters = {}
    L = len(layer_dims)            # number of layers in the network

    for l in range(1, L):
        parameters['W'+str(l)] = np.random.randn(layer_dims[l],layer_dims[l-1])*0.01
        parameters['b'+str(l)] = np.zeros((layer_dims[l],1))
        ### END CODE HERE ###
        
        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))
        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))

        
    return parameters

def sigmoid(Z):
    """
    Implements the sigmoid activation in numpy
    
    Arguments:
    Z -- numpy array of any shape
    
    Returns:
    A -- output of sigmoid(z), same shape as Z
    cache -- returns Z as well, useful during backpropagation
    """
    
    A = 1/(1+np.exp(-Z))
    cache = Z
    
    return A, cache

def relu(Z):
    """
    Implement the RELU function.

    Arguments:
    Z -- Output of the linear layer, of any shape

    Returns:
    A -- Post-activation parameter, of the same shape as Z
    cache -- a python dictionary containing "A" ; stored for computing the backward pass efficiently
    """
    
    A = np.maximum(0,Z)
    
    assert(A.shape == Z.shape)
    
    cache = Z 
    return A, cache

def linear_activation_forward(A_prev, W, b, activation):
    """
    Implement the forward propagation for the LINEAR->ACTIVATION layer

    Arguments:
    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)
    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
    b -- bias vector, numpy array of shape (size of the current layer, 1)
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"

    Returns:
    A -- the output of the activation function, also called the post-activation value 
    cache -- a python dictionary containing "linear_cache" and "activation_cache";
             stored for computing the backward pass efficiently
    """
    
    if activation == "sigmoid":
        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
        ### START CODE HERE ### (≈ 2 lines of code)
        Z = np.dot(W,A_prev)+b
        A,activation_cache = sigmoid(Z)
        ### END CODE HERE ###
    
    elif activation == "relu":
        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
        ### START CODE HERE ### (≈ 2 lines of code)
        Z = np.dot(W,A_prev)+b
        A,activation_cache = relu(Z)
        ### END CODE HERE ###
    
    assert (A.shape == (W.shape[0], A_prev.shape[1]))
    cache = (linear_cache, activation_cache)

    return A, cache

def L_model_forward(X, parameters):
    """
    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation
    
    Arguments:
    X -- data, numpy array of shape (input size, number of examples)
    parameters -- output of initialize_parameters_deep()
    
    Returns:
    AL -- last post-activation value
    caches -- list of caches containing:
                every cache of linear_relu_forward() (there are L-1 of them, indexed from 0 to L-2)
                the cache of linear_sigmoid_forward() (there is one, indexed L-1)
    """

    caches = []
    A = X
    L = len(parameters) // 2                  # number of layers in the neural network
    
    
    # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list.
    for l in range(1, L):
        A_prev = A 
        ### START CODE HERE ### (≈ 2 lines of code)
        A,cache = linear_activation_forward(A_prev, parameters['W'+str(l)], parameters['b'+str(l)], activation='relu')
        caches.append(cache)
        ### END CODE HERE ###
    
    # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list.
    ### START CODE HERE ### (≈ 2 lines of code)
    AL,cache = linear_activation_forward(A, parameters['W'+str(L)], parameters['b'+str(L)], activation='sigmoid')
    caches.append(cache)
    ### END CODE HERE ###
    
    assert(AL.shape == (1,X.shape[1]))
            
    return AL, caches

def compute_cost(AL, Y):
    """
    Implement the cost function defined by equation (7).

    Arguments:
    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)
    Y -- true "label" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)

    Returns:
    cost -- cross-entropy cost
    """
    
    m = Y.shape[1]

    # Compute loss from aL and y.
    ### START CODE HERE ### (≈ 1 lines of code)
    ##attention! here Y,and np.log(AL) is scalar so use multiply rather than dot
    cost = (-1./m)*np.sum(np.multiply(Y,np.log(AL))+np.multiply(1-Y,np.log(1-AL)))
    ### END CODE HERE ###
    
    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).
    assert(cost.shape == ())
    
    return cost

def relu_backward(dA, cache):
    """
    Implement the backward propagation for a single RELU unit.

    Arguments:
    dA -- post-activation gradient, of any shape
    cache -- 'Z' where we store for computing backward propagation efficiently

    Returns:
    dZ -- Gradient of the cost with respect to Z
    """
    
    Z = cache
    dZ = np.array(dA, copy=True) # just converting dz to a correct object.
    
    # When z <= 0, you should set dz to 0 as well. 
    dZ[Z <= 0] = 0
    
    assert (dZ.shape == Z.shape)
    
    return dZ

def sigmoid_backward(dA, cache):
    """
    Implement the backward propagation for a single SIGMOID unit.

    Arguments:
    dA -- post-activation gradient, of any shape
    cache -- 'Z' where we store for computing backward propagation efficiently

    Returns:
    dZ -- Gradient of the cost with respect to Z
    """
    
    Z = cache
    
    s = 1/(1+np.exp(-Z))
    dZ = dA * s * (1-s)
    
    assert (dZ.shape == Z.shape)
    
    return dZ

def linear_backward(dZ, cache):
    """
    Implement the linear portion of backward propagation for a single layer (layer l)

    Arguments:
    dZ -- Gradient of the cost with respect to the linear output (of current layer l)
    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer

    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    A_prev, W, b = cache
    m = A_prev.shape[1]

    ### START CODE HERE ### (≈ 3 lines of code)
    dA_prev = np.dot(W.T,dZ)
    dW = (1/m)*np.dot(dZ,A_prev.T)
    db = (1/m)*np.sum(dZ,axis=1,keepdims = True)
    ### END CODE HERE ###

    assert (dA_prev.shape == A_prev.shape)
    assert (dW.shape == W.shape)
    assert (db.shape == b.shape)
    
    return dA_prev, dW, db

def linear_activation_backward(dA, cache, activation):
    """
    Implement the backward propagation for the LINEAR->ACTIVATION layer.
    
    Arguments:
    dA -- post-activation gradient for current layer l 
    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
    
    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    linear_cache, activation_cache = cache
    
    if activation == "relu":
        ### START CODE HERE ### (≈ 2 lines of code)
        dZ = relu_backward(dA, activation_cache)
        dA_prev,dW,db = linear_backward(dZ,linear_cache)
        ### END CODE HERE ###
        
    elif activation == "sigmoid":
        ### START CODE HERE ### (≈ 2 lines of code)
        dZ = sigmoid_backward(dA, activation_cache)
        dA_prev,dW,db = linear_backward(dZ,linear_cache)
        ### END CODE HERE ###
    
    return dA_prev, dW, db

# GRADED FUNCTION: L_model_backward

def L_model_backward(AL, Y, caches):
    """
    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group
    
    Arguments:
    AL -- probability vector, output of the forward propagation (L_model_forward())
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat)
    caches -- list of caches containing:
                every cache of linear_activation_forward() with "relu" (it's caches[l], for l in range(L-1) i.e l = 0...L-2)
                the cache of linear_activation_forward() with "sigmoid" (it's caches[L-1])
    
    Returns:
    grads -- A dictionary with the gradients
             grads["dA" + str(l)] = ... 
             grads["dW" + str(l)] = ...
             grads["db" + str(l)] = ... 
    """
    grads = {}
    L = len(caches) # the number of layers
    m = AL.shape[1]
    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL
    
    # Initializing the backpropagation
    ### START CODE HERE ### (1 line of code)
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL)) 
    ### END CODE HERE ###
    
    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "AL, Y, caches". Outputs: "grads["dAL"], grads["dWL"], grads["dbL"]
    ### START CODE HERE ### (approx. 2 lines)
    current_cache = caches[-1]
    grads["dA"+str(L)],grads["dW"+str(L)],grads["db"+str(L)] = linear_activation_backward(dAL, current_cache, 'sigmoid')
    ### END CODE HERE ###
    
    for l in reversed(range(L-1)):
        # lth layer: (RELU -> LINEAR) gradients.
        # Inputs: "grads["dA" + str(l + 2)], caches". Outputs: "grads["dA" + str(l + 1)] , grads["dW" + str(l + 1)] , grads["db" + str(l + 1)] 
        ### START CODE HERE ### (approx. 5 lines)
        current_cache = caches[l];
        current_A = grads["dA"+str(l+2)]
        grads["dA" + str(l + 1)],grads["dW" + str(l + 1)],grads["db" + str(l + 1)] = linear_activation_backward(current_A, current_cache, 'relu')
        ### END CODE HERE ###

    return grads

def update_parameters(parameters, grads, learning_rate):
    """
    Update parameters using gradient descent
    
    Arguments:
    parameters -- python dictionary containing your parameters 
    grads -- python dictionary containing your gradients, output of L_model_backward
    
    Returns:
    parameters -- python dictionary containing your updated parameters 
                  parameters["W" + str(l)] = ... 
                  parameters["b" + str(l)] = ...
    """
    
    L = len(parameters) // 2 # number of layers in the neural network

    # Update rule for each parameter. Use a for loop.
    ### START CODE HERE ### (≈ 3 lines of code)
    for l in range(L):
        parameters["W"+str(l+1)]-=learning_rate*grads["dW"+str(l+1)]
        parameters["b"+str(l+1)]-=learning_rate*grads["db"+str(l+1)]
        
    ### END CODE HERE ###
        
    return parameters

import numpy as np

def propogate(w,b,X,Y):

    """
    :param w: (n,1)
    :param b: scalar
    :param X: (n,m)
    :param Y: (1,n)
    :return: grads a dict that saves the params dw,db
            cost saves the cost after each iteration
    """
    #np.squeeze
    #squeeze 函数：从数组的形状中删除单维度条目，即把shape中为1的维度去掉
    m = X.shape[1]

    Yba = np.dot(w.T,X) + b

    cost = np.squeeze((0.5/m *np.dot((Yba-Y),(Yba-Y).T)))

    dw = (1./m) * np.dot(X,(Yba-Y).T)

    db = (1./m) * np.squeeze(np.sum(Yba-Y))
    #save the updated result to the grads dict
    grads = {"dw":dw,"db":db}

    return grads,cost

def optimize(w,b,X,Y,epochs,learning_rate,l2):
    """
    
    :param w: (n,1) 
    :param b: scalar
    :param X: (n,m)
    :param Y: (1,n)
    :param epochs: 迭代次数 
    :param learning_rate: 
    :param l2: 正则化系数 
    :return: params
            grads save the final params ,used for test
            costs save the cost
    """

    costs = []

    for i in range(epochs):
        grads,cost = propogate(w,b,X,Y)
        dw = grads["dw"]
        db = grads["db"]

        w-=learning_rate*dw+l2*w
        b-=learning_rate*db

    params = {"w":w,"b":b}
    grads = {"dw":dw,"db":db}

    return params,grads,costs

def main(x_train, y_train,n,epoches,learning_rate,l2):
    """训练模型，并返回从x到y的映射。"""

    # 使用线性回归训练模型，根据训练集计算最优化参数
    ## 请补全此处代码，替换以下示例
    m = x_train.shape[0]
    w = (np.random.randn(n,1))
    X = np.zeros((n,m),dtype = np.float64)
    b = np.float(0)
    for i in range(n):
        X[i,:] = x_train**(i+1)
    Y = np.float64(np.reshape(y_train,newshape=(1,m)))
    params,grads,costs = optimize(w,b,X,Y,epoches,learning_rate,l2)
    w = params['w']
    b = params['b']
    def f(x):
        ## 请补全此处代码，替换以下示例
        m = x.shape[0]

        X = np.zeros((n,m))
        for i in range(n):
            X[i,:] = x**(i+1)
        y = b+np.dot(w.T,X)
        return y.squeeze()
        pass

    return f

import numpy as np

def propogate(w,b,X,Y,mu,s):

    m = X.shape[1]
    Z = (X-mu)/s
    A = np.exp(-(Z*Z)/2)
    Yba = np.dot(w.T,A) + b
    cost = np.squeeze((0.5/m *np.dot((Yba-Y),(Yba-Y).T)))

    dY = 1./m*(Yba-Y)
    dw = np.dot(A,dY.T)
    db = np.squeeze(np.sum(dY))
    dA = w*dY
    dZ = dA*A*(-Z)
    dmu = 1./m*np.sum(dZ*(-1/s),axis=1,keepdims=True)
    ds = 1./m*np.sum(dZ*(-(X-mu)/(s*s)),axis=1,keepdims=True)


    grads = {"dw":dw,"db":db,"dmu":dmu,"ds":ds}

    return grads,cost


def optimize(w,b,X,Y,mu,s,epochs,learning_rate,l2):

    costs = []

    for i in range(epochs):
        grads,cost = propogate(w,b,X,Y,mu,s)
        dw = grads["dw"]
        db = grads["db"]
        dmu = grads["dmu"]
        ds = grads["ds"]

        w-=learning_rate*dw+l2*w
        b-=learning_rate*db+l2*b
        mu-=learning_rate*dmu+l2*mu
        s -=learning_rate*ds+l2*s

        costs.append(cost)

    params = {"w":w,"b":b,"mu":mu,"s":s}


    return params,costs



def main(x_train, y_train,n,epoches,learning_rate,l2):
    """训练模型，并返回从x到y的映射。"""

    # 使用线性回归训练模型，根据训练集计算最优化参数
    ## 请补全此处代码，替换以下示例
    m = x_train.shape[0]
    w = (np.random.randn(n,1))
    # means of gaussian
    mu = np.random.randn(n,1)
    #I still have no idea why set like this?
    for i in range(n):
        mu[i,0]+=i*40
    X = np.zeros((n,m),dtype = np.float64)
    b = np.float(0)
    for i in range(n):
        X[i,:] = x_train
    Y = np.float64(np.reshape(y_train,newshape=(1,m)))

    #initalize s if s is too close to 0 then it will go wrong
    while True:
        flag = True
        s = np.random.randn(n,1)
        jump = np.int32(np.abs(s)<1)
        if(np.sum(jump))>=1:
            flag = False
        if flag is True:
            break

    params,costs = optimize(w,b,X,Y,mu,s,epoches,learning_rate,l2)
    w = params['w']
    b = params['b']
    mu = params['mu']
    s = params['s']
    def f(x):
        ## 请补全此处代码，替换以下示例
        m = x.shape[0]

        X = np.zeros((n,m))
        for i in range(n):
            X[i,:] = x
        Z = (X-mu)/s
        A = np.exp(-(Z*Z)/2)
        y = b+np.dot(w.T,A)
        return y.squeeze()
        pass

    return f

import numpy as np

def sigmoidFunction(z):
    return 1./(1+np.exp(-z))


def propogate(w,b,X,Y,mu,s):

    m = X.shape[1]
    Z = (X-mu)/s
    A = sigmoidFunction(Z)
    Yba = np.dot(w.T,A) + b
    cost = np.squeeze((0.5/m *np.dot((Yba-Y),(Yba-Y).T)))

    dY = 1./m*(Yba-Y)
    dw = np.dot(A,dY.T)
    db = np.squeeze(np.sum(dY))
    dA = w*dY
    dZ = dA*A*(1-A)
    dmu = 1./m*np.sum(dZ*(-1./s),axis=1,keepdims=True)
    ds = 1./m*np.sum(dZ*(-(X-mu)/(s*s)),axis=1,keepdims=True)


    grads = {"dw":dw,"db":db,"dmu":dmu,"ds":ds}

    return grads,cost


def optimize(w,b,X,Y,mu,s,epochs,learning_rate,l2):



    costs = []

    for i in range(epochs):
        grads,cost = propogate(w,b,X,Y,mu,s)
        dw = grads["dw"]
        db = grads["db"]
        dmu = grads["dmu"]
        ds = grads["ds"]

        w-=learning_rate*dw+l2*w
        b-=learning_rate*db+l2*b
        mu-=learning_rate*dmu+l2*mu
        s -=learning_rate*ds+l2*s

        costs.append(cost)

    params = {"w":w,"b":b,"mu":mu,"s":s}


    return params,costs



def main(x_train, y_train,n,epoches,learning_rate,l2):
    """训练模型，并返回从x到y的映射。"""

    # 使用线性回归训练模型，根据训练集计算最优化参数
    ## 请补全此处代码，替换以下示例
    m = x_train.shape[0]
    w = (np.random.randn(n,1))
    # means of gaussian
    mu = np.random.randn(n,1)
    # mu is the mean of the sigmoid
    for i in range(n):
        mu[i,0]+= i*100/n
    X = np.zeros((n,m),dtype = np.float64)
    b = np.float(0)
    for i in range(n):
        X[i,:] = x_train
    Y = np.float64(np.reshape(y_train,newshape=(1,m)))

    #initalize s if s is too close to 0 then it will go wrong
    while True:
        flag = True
        s = np.random.randn(n,1)
        jump = np.int32(np.abs(s)<1)
        if(np.sum(jump))>=1:
            flag = False
        if flag is True:
            break

    params,costs = optimize(w,b,X,Y,mu,s,epoches,learning_rate,l2)
    w = params['w']
    b = params['b']
    mu = params['mu']
    s = params['s']
    def f(x):
        ## 请补全此处代码，替换以下示例
        m = x.shape[0]

        X = np.zeros((n,m))
        for i in range(n):
            X[i,:] = x
        Z = (X-mu)/s
        A = sigmoidFunction(Z)
        y = b+np.dot(w.T,A)
        return y.squeeze()
        pass

    return f

P(slots);       //empty slot-1
P(mutex);		//进入临界区
insert_item
V(mutex);		//离开临界区
V(items);		//full slot+1

P(items);		//满槽数目-1
P(mutex);		
remove_item;
V(mutex);
V(slots);		//空槽数目+1

int a = 3;  //静态变量，外部链接性
static int b = 4;  //静态变量，内部链接性
 
void fun()
{
	static int c = 5;  //静态变量，无链接性
}

int a = 2;
 
void fun()
{
	int a = 3;  //这是自动变量，会覆盖掉全局静态变量a
}

/* You won't lose style points for including this long line in your code */
static const char *user_agent_hdr = "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3\r\n";
static const char *conn_hdr = "Connection: close\r\n";
static const char *prox_hdr = "Proxy-Connection: close\r\n";
static const char *hostFormat = "Host: %s\r\n";
static const char *requestHeaderFormat = "GET %s HTTP/1.0\r\n";
static const char *endof_hdr = "\r\n";
static const char *connection_key = "Connection";
static const char *user_agent_key= "User-Agent";
static const char *proxy_connection_key = "Proxy-Connection";
static const char *hostKey = "Host";

void doit(int fd);
void parse_uri(char *uri,char *hostname,char *path,int *port);
void buildHTTPHeader(char *http_header,char *hostname,char *path,int port,rio_t *client_rio);
int connectEndServer(char *hostname,int port,char *httpHeader);
void *thread(void *vargp);
void initCache();
int reader(int fd,char *uri);
void writer(char *uri,char *buf);
//reference: https://zhuanlan.zhihu.com/p/37902495

typedef struct{
    char *buf;
    char *uri;
}cacheLine;

typedef struct{
    cacheLine* objects;
    int count;
}Cache;

Cache cache;
int readCount;
sem_t mutex,wmutex;
//用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制

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

    int listenfd,connfd;
    socklen_t clientlen;
    char hostname[MAXLINE];
    char port[MAXLINE];
    struct sockaddr_storage clientaddr;
    pthread_t tid;
    if(argc!=2){
        fprintf(stderr,"usage %s <port>\n",argv[0]);
        exit(1);
    }
    initCache();
    //ignore the SIGPIPE signal
    signal(SIGPIPE, SIG_IGN);
    //transfrom the fd to listenfd
    listenfd = Open_listenfd(argv[1]);
    while(1){
        clientlen = sizeof(clientaddr);
        connfd = Accept(listenfd,(SA*)&clientaddr,&clientlen);
        //ip->host name
        Getnameinfo((SA *)&clientaddr,clientlen,hostname,MAXLINE,port,MAXLINE,0);
        printf("Accepted connection from (%s %s)\n",hostname,port);
        //pass value of connfd to create function to avoid competition
        Pthread_create(&tid,NULL,thread,(void*)connfd);
    }
    return 0;
}

void *thread(void *vargp){
    int connfd = (int)vargp;
    //要把线程分离出去，让这个线程计数结束之后自己回收资源，避免内存泄露。
    Pthread_detach(pthread_self());
    doit(connfd);
    Close(connfd);
}

//对客户端请求的HTTP header 进行处理，首先获得request header
//eg: GET http://www.zhihu.com HTTP/1.1
//然后对于请求URL进行分析，获取需要连接的服务器的hostname，port，
//修改客户端的HTTP，让proxy充当客户端把信息转发给正确的服务器，然后接收服务器
//的返回并转发给正确的客户端
void doit(int connfd){

    char buf[MAXLINE],uri[MAXLINE],method[MAXLINE],version[MAXLINE];
    //parseRequest(fd,&requestLine,headers,&numHead);
    char endServerHTTP [MAXLINE];
    char hostname[MAXLINE],path[MAXLINE];
    char objectBUF[MAX_OBJECT_SIZE];
    int port,endServerFd;

    rio_t rio,serverRio;

    Rio_readinitb(&rio,connfd);
    Rio_readlineb(&rio,buf,MAXLINE);
    //read GET http://www.zhihu.com HTTP/1.1
    //format read function
    sscanf(buf,"%s %s %s",method,uri,version);
    
    if(strcasecmp(method,"GET")){
        printf("Proxy does not implement the method");
        return;
    }

    //parse the uri and save the hostname,path,port number to the argument
    parse_uri(uri,hostname,path,&port);

    //build the http header which will send to the end server
    buildHTTPHeader(endServerHTTP,hostname,path,port,&rio);


    strcpy(uri,hostname);
    strcpy(uri+strlen(uri),path);
    if(reader(connfd,uri)){
        fprintf(stdout,"%s from cache\n",uri);
        fflush(stdout);
        return;
    }

    int totalSize = 0;
    //connect to the end server;
    endServerFd = connectEndServer(hostname,port);
    if(endServerFd<0){
        printf("connection failed");
        return;
    }
    Rio_readinitb(&serverRio,endServerFd);
    Rio_writen(endServerFd,endServerHTTP,strlen(endServerHTTP));

    //receive message from end server and send to client
    size_t n;
    while((n=Rio_readlineb(&serverRio,buf,MAXLINE))){
        printf("proxy received %ld bytes,then send.\n",n);
        Rio_writen(connfd,buf,n);
        strcpy(objectBUF+totalSize,buf);
        totalSize+=n;
    }
   //each objectBUF save all info of the request
    if(totalSize<MAX_OBJECT_SIZE)
        writer(uri,objectBUF);
    Close(endServerFd);
}

void buildHTTPHeader(char *http_header,char *hostname,char *path,int port,rio_t *client_rio){

    char buf[MAXLINE],requestHeader[MAXLINE],otherHeader[MAXLINE],hostHeader[MAXLINE];

    //request line
    //static const char *requestHeaderFormat = "GET %s HTTP/1.0\r\n";
    //把path内容按照格式写入requestHeader
    sprintf(requestHeader,requestHeaderFormat,path);
    while(Rio_readlineb(client_rio,buf,MAXLINE)>0){

        if(!strcmp(buf,endof_hdr)){
            break; //EOF
        }
        //Host
        if(!strncasecmp(buf,hostKey,strlen(hostKey))){
            strcpy(hostHeader,buf);
            continue;
        }
        if(!strncasecmp(buf,connection_key,strlen(connection_key))&&!
            strncasecmp(buf,proxy_connection_key,strlen(proxy_connection_key)),
            !strncasecmp(buf,user_agent_key,strlen(user_agent_key))){
            //把两个串连接起来
            strcat(otherHeader,buf);
        }

    }
    if(strlen(hostHeader)==0){
        sprintf(hostHeader,hostFormat,buf);
    }
    //static const char *user_agent_hdr = "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3\r\n";
    //static const char *conn_hdr = "Connection: close\r\n";
    //static const char *prox_hdr = "Proxy-Connection: close\r\n";
    //static const char *endof_hdr = "\r\n";
    
    //put all header to http_header
    sprintf(http_header,"%s%s%s%s%s%s%s",requestHeader,hostHeader,
            conn_hdr,prox_hdr,user_agent_hdr,otherHeader,endof_hdr);
    return;
}

void parse_uri(char *uri,char *hostname,char *path,int *port){

    //strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
    //如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

    *port = 80;
    char *pos1 = strstr(uri,"//");

    if(pos1){
        pos1 =  pos1+2;
    }else{
        pos1 = uri;
    }

    char *pos2 = strstr(pos1,":");
    //case the uri has the port info
    if(pos2){

        //          userinfo     host        port
        //          ┌─┴────┐ ┌────┴────────┐ ┌┴┐
        //  https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top
        //  └─┬─┘ └───────┬────────────────────┘└─┬─────────────┘└──┬───────────────────────┘└┬─┘
        //  scheme     authority                 path              query                      fragment


        //initalize the head of pos2 is \0 i.e clean the pos2
        *pos2 = '\0';
        sscanf(pos1,"%s",hostname);
        sscanf(pos2+1,"%d%s",port,path);
    }
    else{
        //
        //telnet://192.0.2.16:80/xxx
        //└──┬─┘ └──────┬──────┘│
        //scheme    authority  path
        // no port info
        pos2 = strstr(pos1,"/");
        if(pos2){
            sscanf(pos1,"%s",hostname);
            *pos2 = '/';
            sscanf(pos2,"%s",path);
        }
        //only hostname info
        else{
            sscanf(pos1,"%s",hostname);
        }
    }
    return;
}

inline int connectEndServer(char *hostname,int port){

    char portStr[100];
    sprintf(portStr,"%d",port);
    return Open_clientfd(hostname,portStr);

}

int reader(int fd,char *uri){

    //here uri = each server's hostname+path
    int Found = 0;
    P(&mutex);
    readCount++;
    if(readCount==1){
        P(&wmutex);
    }
    V(&mutex);

    for(int i=0;i<10;i++){
        if(!strcmp(cache.objects[i].uri,uri)){
            Rio_writen(fd,cache.objects[i].buf,MAX_OBJECT_SIZE);
            Found=1;
            break;
        }
    }

    P(&mutex);
    readCount--;
    if(readCount==0){
        V(&wmutex);
    }
    V(&mutex);
    return Found;
}

void writer(char *uri,char *buf){

    P(&wmutex);
    strcpy(cache.objects[cache.count].uri,uri);
    strcpy(cache.objects[cache.count].buf,buf);
    ++cache.count;
    V(&wmutex);
}

//simple cache no use LRU,just split the memory to 10 block,
//each time use a loop to find whether the uri of the request is in the block
//在server和client之间加入代理的好处之一，就可以实现cache化。
//因为，经常有很多对同一个资源多次请求的情况，如果每次都从服务端获取，那样服务器会很累。
//如果可以在代理部分就实现一个cache，
//将最近客户端请求过的数据给存储起来，那样就不需要每次都要从服务器请求了，进而提高服务器的效率。


void initCache(){

    sem_init(&mutex,0,1);
    sem_init(&wmutex,0,1);
    cache.objects = (cacheLine*)malloc(sizeof(cacheLine)*10);
    cache.count=0;
    readCount=0;
    for(int i=0;i<10;i++){
        cache.objects[i].buf = malloc(sizeof(char)*MAXLINE);
        cache.objects[i].uri = malloc(sizeof(char)*MAX_OBJECT_SIZE);
    }
}

curl -v --proxy http://localhost:23885/ http://localhost:4501/

void sigchld_handler(int sig){
    while (waitpid(-1, 0, WNOHANG) > 0)
        ;
    return;
    // Reap all zombie children
}
int main(int argc, char **argv) {
    int listenfd, connfd;
    socklen_t clientlen;
    struct sockaddr_storage clientaddr;
    
    Signal(SIGCHLD, sigchld_handler);
    listenfd = Open_listenfd(argv[1]);
    while (1) {
        clientlen = sizeof(struct sockaddr_storage);
        connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
        if (Fork() == 0) {
            Close(listenfd); // Child closes its listening socket
            echo(connfd); // Child services client
            Close(connfd); // Child closes connection with client
            exit(0); // Child exits
        }
        Close(connfd); // Parent closes connected socket (important!)
    }
}

volatile int cnt=0; 
sem_t mutex; //声明信号量mutex

Sem_init(&mutex,0,1);//主线程中初始化


//在线程例程中对共享变量cnt的更新包围P和V操作，从而保护他们
for(i=0;i<niters;i++){

    P(&mutex);
    cnt++;
    V(&mutex);
}

// 版本一
void *foo(void *vargp)
{
    int myid;
    myid = *((int *)vargp);
    Free(vargp);
    printf("Thread %d\n", myid);
}
int main()
{
    pthread_t tid[2];
    int i, *ptr;
    
    for (i = 0; i < 2; i++)
    {
        ptr = Malloc(sizeof(int));
        *ptr = i;
        Pthread_create(&tid[i], 0, foo, ptr);
    }
    Pthread_join(tid[0], 0);
    Pthread_join(tid[1], 0);
}

// 版本二
void *foo(void *vargp)
{
    int myid;
    myid = *((int *)vargp);
    printf("Thread %d\n", myid);
}
int main()
{
    pthread_t tid[2];
    int i;
    
    for (i = 0; i < 2; i++)
        Pthread_create(&tid[i], NULL, foo, &i);
    Pthread_join(tid[0], NULL);
    Pthread_join(tid[1], NULL);
}

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

	struct addrinfo *p,*listp,hints;
	char buf[MAXLINE];
	int rc,flags;

	if(argc!=2){
		fprintf(stderr,"usage: %s <domain name>\n",argv[0]);
		exit(0);
	}
	
	//get a list of addinfo records
	memset(&hints,0,sizeof(struct addrinfo));
	hints.ai_family = AF_INET;
	hints.ai_socktype = SOCK_STREAM;
	if((rc=getaddrinfo(argv[1],NULL,&hints,&listp))!=0){
		fprintf(stderr,"getaddrinfo error: %s\n",gai_strerror(rc));
		exit(1);
	}
	
	flags = NI_NUMERICHOST;

	for(p=listp;p;p = p->ai_next){
		Getnameinfo(p->ai_addr,p->ai_addrlen,buf,MAXLINE,NULL,0,flags);
		printf("%s\n",buf);
	}

	Freeaddrinfo(listp);

	exit(0);
}

#include "csapp.h"

int main(void)
{
    char c;

    while(Read(STDIN_FILENO, &c, 1) != 0)
        Write(STDOUT_FILENO, &c, 1);
    exit(0);
}

fd(5,0)