• 2017-2018-1 20155334第八周课堂实践总结+课下作业+教材内容总结


    2017-2018-1 20155334第八周课堂实践总结+课下作业+教材内容总结

    第八周测试的2、3项目在课上已经提交了

    第八周测试-1:

    lude <stdio.h>
     int main(int argc,char *argv[]){
               int sum=0,i=0;
               for(i=1;i<argc;i++){
                       sum+=atoi(argv[i]);
               }
               printf("%d
    ",sum);
       }
    

    第八周课下作业1:

    1. 完成家庭作业4.47,4.48,4.49
    2. 相应代码反汇编成X86-64汇编
    3. 把上述X86-64汇编翻译成Y86汇编,并给出相应机器码

    家庭作业4,47:

    void bubble(int *data, int count) { 
    
        if(count == 0)
        return;
        int i, j;
        int *p, *q; 
        for(i=count-1; i!=0; i--)
        {
            p = data, q = data + 1;
            for(j=0; j!=i; ++j)
            { 
                if( *p > *q )
                { 
                    int t = *p;*p = *q;
                    *q = t;
                } 
                p++, q++;
            }
        }
    }
    

    汇编代码:

    00000000 <bubble_p>:
       0:   56                      push   %esi
       1:   53                      push   %ebx
       2:   8b 44 24 10             mov    0x10(%esp),%eax
       6:   8b 54 24 0c             mov    0xc(%esp),%edx
       a:   8d 70 ff                lea    -0x1(%eax),%esi
       d:   85 f6                   test   %esi,%esi
       f:   7e 2d                   jle    3e <bubble_p+0x3e>
      11:   8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi
      18:   31 c0                   xor    %eax,%eax
      1a:   8d b6 00 00 00 00       lea    0x0(%esi),%esi
      20:   8b 4c 82 04             mov    0x4(%edx,%eax,4),%ecx
      24:   8b 1c 82                mov    (%edx,%eax,4),%ebx
      27:   39 d9                   cmp    %ebx,%ecx
      29:   7d 07                   jge    32 <bubble_p+0x32>
      2b:   89 5c 82 04             mov    %ebx,0x4(%edx,%eax,4)
      2f:   89 0c 82                mov    %ecx,(%edx,%eax,4)
      32:   83 c0 01                add    $0x1,%eax
      35:   39 f0                   cmp    %esi,%eax
      37:   7c e7                   jl     20 <bubble_p+0x20>
      39:   83 ee 01                sub    $0x1,%esi
      3c:   75 da                   jne    18 <bubble_p+0x18>
      3e:   5b                      pop    %ebx
      3f:   5e                      pop    %esi
      
    Disassembly of section .text.startup:
    
    00000000 <main>:
       0:   31 c0                   xor    %eax,%eax
    
    y86:
    
    0x0000:                        | Disassembly of section .text:
                                   | 
    0x0000:                        | 00000000 <bubble_p>:
    0x0000:                        |    0:  56                      push   %esi
    0x0000:                        |    1:  53                      push   %ebx
    0x0000:                        |    2:  8b 44 24 10             mov    0x10(%esp),%eax
    0x0000:                        |    6:  8b 54 24 0c             mov    0xc(%esp),%edx
    0x0000:                        |    a:  8d 70 ff                lea    -0x1(%eax),%esi
    0x0000:                        |    d:  85 f6                   test   %esi,%esi
    0x0000:                        |    f:  7e 2d                   jle    3e <bubble_p+0x3e>
    0x0000:                        |   11:  8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi
    0x0000:                        |   18:  31 c0                   xor    %eax,%eax
    0x0000:                        |   1a:  8d b6 00 00 00 00       lea    0x0(%esi),%esi
    0x0000:                        |   20:  8b 4c 82 04             mov    0x4(%edx,%eax,4),%ecx
    0x0000:                        |   24:  8b 1c 82                mov    (%edx,%eax,4),%ebx
    0x0000:                        |   27:  39 d9                   cmp    %ebx,%ecx
    0x0000:                        |   29:  7d 07                   jge    32 <bubble_p+0x32>
    0x0000:                        |   2b:  89 5c 82 04             mov    %ebx,0x4(%edx,%eax,4)
    0x0000:                        |   2f:  89 0c 82                mov    %ecx,(%edx,%eax,4)
    0x0000:                        |   32:  83 c0 01                add    $0x1,%eax
    0x0000:                        |   35:  39 f0                   cmp    %esi,%eax
    0x0000:                        |   37:  7c e7                   jl     20 <bubble_p+0x20>
    0x0000:                        |   39:  83 ee 01                sub    $0x1,%esi
    0x0000:                        |   3c:  75 da                   jne    18 <bubble_p+0x18>
    0x0000:                        |   3e:  5b                      pop    %ebx
    0x0000:                        |   3f:  5e                      pop    %esi
                                   |   
    0x0000:                        | Disassembly of section .text.startup:
                                   | 
    0x0000:                        | 00000000 <main>:
    0x0000:                        |    0:  31 c0                   xor    %eax,%eax
                                   |   
                                   |
    
    ### 第八周课下作业2:
    1. 把课上练习3的daytime服务器分别用多进程和多线程实现成并发服务器并测试 
    client.c: 
    
    /*
     * echoclient.c - An echo client
     */
    /* $begin echoclientmain */
    #include "csapp.h"
    
    int main(int argc, char **argv) 
    {
        int clientfd, port;
        char *host, buf[MAXLINE];
        rio_t rio;
    
        if (argc != 3) {
        fprintf(stderr, "usage: %s <host> <port>
    ", argv[0]);
        exit(0);
        }
        host = argv[1];
        port = atoi(argv[2]);
    
        clientfd = Open_clientfd(host, port);
        Rio_readinitb(&rio, clientfd);
    
        while (Fgets(buf, MAXLINE, stdin) != NULL) {
        
        time_t t;
        struct tm * lt;
        size_t n; 
        printf("
    客户端IP:127.0.0.1
    ");
        printf("服务器实现者学号:20155334
    ");
        
        time (&t);//获取Unix时间
        lt = localtime (&t);//时间结构
        printf ("当前时间为:%d/%d/%d %d:%d:%d
    ",lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec);//输出结果。
        Rio_writen(clientfd, buf, strlen(buf));
        Rio_readlineb(&rio, buf, MAXLINE);
        Fputs(buf, stdout);
        }
        Close(clientfd); //line:netp:echoclient:close
        exit(0);
    }
    /* $end echoclientmain */
    
    多进程实现
    修改server3.c代码:
    
    #include "csapp.h"
    void echo(int connfd,char *haddrp);
    
    void sigchld_handler(int sig) //line:conc:echoserverp:handlerstart
    {
        while (waitpid(-1, 0, WNOHANG) > 0)
        ;
        return;
    } 
    
    int main(int argc, char **argv) 
    {
        int listenfd, connfd, port;
        char *haddrp;
        socklen_t clientlen=sizeof(struct sockaddr_in);
        struct sockaddr_in clientaddr;
    
        if (argc != 2) {
        fprintf(stderr, "usage: %s <port>
    ", argv[0]);
        exit(0);
        }
        port = atoi(argv[1]);
    
        Signal(SIGCHLD, sigchld_handler);
        listenfd = Open_listenfd(port);
        while (1) {
        connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
        if (Fork() == 0) { 
            haddrp = inet_ntoa(clientaddr.sin_addr);
            Close(listenfd); 
            echo(connfd,haddrp);   
            Close(connfd);   
            exit(0);    
        }
        Close(connfd); 
        }
    }
    

    教材内容总结

    第十一章

    1. 客户端-服务器编程模型:
      每个网络应用都是基于客户端-服务器模型的。在该模型中,一个应用是由一个服务器进程和一个或多个客户端进程组成的。

    2. 服务器管理某种资源:

      1. 一个Web服务器管理了一组磁盘文件,它会代表客户端进行检索和执行;
      2. 一个FTP服务器管理了一组磁盘文件,它会为客户端进行存储和检索;
      3. 一个Emial服务器管理了一些文件,它为客户端进行读和更新。
    3. 客户端-服务器模型中的基本操作是事务,它由四步组成:

      1. 客户端向服务器发送一个请求,发起一个事务;
      2. 服务器收到请求后,解释之,并操作它的资源;
      3. 服务器给客户端发送一个响应,例如将请求的文件发送回客户端;
      4. 客户端收到响应并处理它,例如Web浏览器在屏幕上显示网页。
    4. 网络域名:

    第十二章

    线程执行模型:


    基于进程的并发编程:
    构造并发编程最简单的方法就是用进程,使用那些大家都很熟悉的函数,像fork、exec和waitpid。

    步骤:
    1)服务器监听一个监听描述符上的连接请求。
    2)服务器接受了客户端1的连接请求,并返回一个已连接描述符。
    3)在接受了连接请求之后,服务器派生一个子进程,这个子进程获得服务器描述符表的完整拷贝。子进程关闭它的拷贝中的监听描述符3,而父进程关闭它的已连接描述符4的拷贝,因为不再需要这些描述符了。
    4)子进程正忙于为客户端提供服务,父进程继续监听新的请求。

    代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
    目标 5000行 30篇 400小时
    第一周 75/75 1/1 5/0
    第二周 135/210 1/2 4/9
    第三周 234/444 1/3 6/15
    第四周 486/930 1/4 8/23
    第五周 753/1683 3/7 43/66
    第六周 503/2186 2/9 54/120
    第七周 823/3006 2/11 43/163
    第八周 756/3762 1/12 52/215

    尝试一下记录「计划学习时间」和「实际学习时间」,到期末看看能不能改进自己的计划能力。这个工作学习中很重要,也很有用。
    耗时估计的公式
    :Y=X+X/N ,Y=X-X/N,训练次数多了,X、Y就接近了。

    参考:软件工程软件的估计为什么这么难软件工程 估计方法

    • 计划学习时间:XX小时

    • 实际学习时间:XX小时

    • 改进情况:

    (有空多看看现代软件工程 课件
    软件工程师能力自我评价表
    )

    参考资料

  • 相关阅读:
    函数指针_typedef
    网络学习_2
    网络学习_1
    字节序
    string相关总结
    C++ const用法总结
    U盘安装CentOS 7.0
    windows平台CodeBlocks MinGW C++11开发环境搭建
    关于32位windows与4GB内存的那些事儿
    开启win7系统关闭日志分析
  • 原文地址:https://www.cnblogs.com/bestixx/p/7822922.html
Copyright © 2020-2023  润新知