20211316郭佳昊 《信息安全系统设计与实现(上)》 第八周学习总结

一、任务要求

[ 1 ] 知识点归纳以及自己最有收获的内容,选择至少2个知识点利用chatgpt等工具进行苏格拉底挑战,并提交过程截图,提示过程参考下面内容 (4分)
我在学***X知识点,请你以苏格拉底的方式对我进行提问,一次一个问题

核心是要求GPT:请你以苏格拉底的方式对我进行提问

然后GPT就会给你提问,如果不知道问题的答案,可以反问AI:你的理解(回答)是什么?

如果你觉得差不多了,可以先问问GPT:针对我XXX知识点,我理解了吗?

GPT会给出它的判断,如果你也觉得自己想清楚了,可以最后问GPT:我的回答结束了,请对我的回答进行评价总结,让它帮你总结一下。

[ 2 ] 问题与解决思路,遇到问题最先使用chatgpt等AI工具解决,并提供过程截图(3分)

[ 3 ] 实践过程截图,代码链接(2分)

[ 4 ] 其他(知识的结构化,知识的完整性等,提交markdown文档,使用openeuler系统等)(1分)

二、知识点总结

并行计算

并行计算是一种计算方案,它尝试使用多个执行并行算法的处理器更快速地解决问题。

顺序算法与并行算法
  • 顺序算法:用一个begin-end代码块列出,可能包含多个步骤,每个步骤通过单个任务依次执行,所有步骤完成时,算法结束。
  • 并行算法:使用cobegin-coend代码块列出,所有任务并行执行。
并行性与并发性

在单CPU系统中,并发性是通过多任务处理来实现的。

线程

线程的原理

线程是某进程同一地址空间上的独立执行单元

线程的优点
  • 线程创建和切换速度更快
  • 线程的响应速度更快
  • 线程更适合并行计算
线程的缺点
  • 由于地址空间共享,线程需要来自用户的明确同步
  • 许多库函数可能对线程不安全
  • 单CPU系统上,使用线程解决问题实际上比使用顺序程序慢,原因在于运行时创建线程和切换上下文的系统开销

线程操作

线程的执行轨迹与进程类似,线程可以在内核模式或用户模式下执行,在用户模式下,线程在进程的相同地址空间中执行

线程管理函数

创建线程

使用pthread_create()函数创建线程。成功返回0,失败则返回错误代码。
int pthread_create(pthread_t *pthread_id,pthread_attr_t *attr,void *(*func)(void*),void *arg)
参数如下:

  • pthread_id是指向pthread_t类型变量的指针,会被操作系统内核分配的唯一线程ID填充
  • attr是指向另一种不透明数据类型的指针
  • func是要执行的新线程函数的入口地址
  • arg是指向线程函数参数的指针,可写为void *func(void *arg)
线程ID

线程ID是一种不透明的数据类型,取决于实现情况,不直接比较线程ID,可以用pthread_equal()函数进行比较int pthread_equal (pthread_t t1, pthread_t t2)线程不同返回0,否则返回非0。

线程终止

线程函数结束后,线程即终止,或调用int pthread_exit (void *status)进行显式终止,返回0正常终止,否则异常终止。

线程链接

一个线程可以等待另一个线程的终止,通过int pthread_join (pthread_t thread, void **status_ptr)终止线程的退出状态以status_ptr返回。

线程示例程序

用线程计算矩阵的和
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define N 4
int A[N][N], sum[N];
void *func(void *arg)
{
    int j, row;
    pthread_t tid = pthread_self(); // get thread ID number 
    row = (int)arg;	// get row number from arg
    printf("Thread %d [%lu] computes sum of row %d\n", row, tid, row); 
    for (j=0; j<N; j++)
    {
        sum[row] += A[row][j];
    }
    printf("Thread %d [%lu] done sum[%d] = %d\n",row, tid, row, sum[row]);
    pthread_exit((void*)0); // thread exit: 0=normal termination
}

int main (int argc, char *argv[])
{
    pthread_t thread[N];	// thread IDs
    int i, j, r, total = 0;
    void *status;
    printf("Main: initialize A matrix\n");

    for (i=0; i<N; i++)
    {
        sum[i] = 0;
        for (j=0; j<N; j++)
        {
            A[i][j] = i*N + j + 1;
            printf("%4d" ,A[i][j]);
        }
    printf("\n");
    }
    printf("Main: create %d threads\n", N);
    for(i=0; i<N; i++)
    {
        pthread_create(&thread[i], NULL, func, (void *)i);
    }
    printf("Main: try to join with threads\n");
    for(i=0; i<N; i++) 
    {
        pthread_join(thread[i], &status);
        printf("Main: joined with %d [%lu]: status=%d\n",i, thread[i], (int)status);
    }
    printf("Main: compute and print total sum:"); 
    for (i=0; i<N; i++)
    {
        total += sum[i];
    }
    printf("tatal = %d\n", total); 
    pthread_exit(NULL);
}

用线程快速排序
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>
#define N 4
double A[N][N+1]; 
pthread_barrier_t barrier;

int print_matrix()
{
    int i, j;
    printf("----------------------------\n");
    for(i=0; i<N; i++)
    {
        for(j=0; j < N+1; j++) 
            printf("%6.2f	", A[i][j]);

        printf("\n");
    }
}

void *ge(void *arg) // threads function: Gauss elimination
{
    int i, j, prow;
    int myid = (int)arg;
    double temp, factor;
    for(i=0; i<N-1; i++)
    {
        if (i == myid)
        {
            printf("partial pivoting by thread %d on row %d: ", myid, i);
            temp = 0.0; prow = i;
            for (j=i; j<=N; j++)
            {
                if (fabs(A[j][i]) > temp)
                {
                    temp = fabs(A[j][i]); 
                    prow = j;
                }
            }
        
            printf("pivot_row=%d pivot=%6.2f\n", prow, A[prow][i]); 
            if (prow != i)	// swap rows
            {
                for (j=i; j<N+1; j++)
                {
                    temp = A[i][j];
                    A[i][j] = A[prow][j];
                    A[prow][j] = temp;
                }
            }
        }
        // wait for partial pivoting done 
        pthread_barrier_wait(&barrier); 
        for(j=i+1; j<N; j++)
        {
            if (j == myid)
            {
                printf("thread %d do row %d\n", myid, j); 
                factor = A[j][i]/A[i][i]; 
                for (int k=i+1; k<=N; k++)
                    A[j][k] -= A[i][k]*factor;
                A[j][i] = 0.0;
            }     
        }
        // wait for current row reductions to finish 
        pthread_barrier_wait(&barrier);
        if (i == myid)
            print_matrix();
    }
}

int main(int argc, char *argv[])
{
    int i, j;
    double sum;
    pthread_t threads[N];
    printf("main: initialize matrix A[N][N+l] as [A|B]\n");
    for (i=0; i<N; i++)
        for (j=0; j<N; j++)
            A[i][j] = 1.0;
    for (i=0; i<N; i++)
        A[i][N-i-1] = 1.0*N;
    for (i=0; i<N; i++)
    {
        A[i][N] = 2.0*N - 1;
    }
    print_matrix();	// show initial matrix [A|B]

    pthread_barrier_init(&barrier, NULL, N); // set up barrier

    printf("main: create N=%d working threads\n", N);
    for (i=0; i<N; i++)
    { 
        pthread_create(&threads[i], NULL, ge, (void *)i);
    }

    printf("main: wait for all %d working threads to join\n", N);
    for (i=0; i<N; i++)
    {
        pthread_join(threads[i], NULL);
    }

    printf("main: back substitution :");
    for (i=N-1; i>=0; i--)
    {
        sum = 0.0;
        for (j=i+1; j<N; j++)
            sum += A[i][N];
            A[i][N] = (A[i][N]- sum)/A[i][i];
    }
    // print solution
    printf("The solution is :\n");
    for(i=0; i<N; i++)
    {
        printf("%6.2f  ",A[i][N]);
    }
    printf("\n");
}

线程同步

由于线程在进程的同一地址空间中执行,它们共享同一地址空间中的所有全局变量和数据结构,当多个线程试图修改同一共享变量或数据结构时,如果修改结果取决于线程的执行和、顺序,则称之为竞态条件。

互斥量

在Pthread中,锁被称为互斥量,意思是相互排斥,互斥变量用pthread_mutex_t类型声明的,使用前需要初始化

死锁预防

死锁是一个状态,在这种状态下,许多执行实体相互等待,无法继续进行下去

信号量

信号量说是进程同步的一般机制,计数信号量是一种数据结构

struct sem{
   int value;
   struct process *queue
}s

三、苏格拉底挑战

posted @ 2023-10-29 16:24  20211316郭佳昊  阅读(21)  评论(0编辑  收藏  举报