基于并行EBE-CG方法的有限元求解程序（从我的毕业论文中节选出来的）

最新推荐文章于 2022-11-23 10:59:11 发布
最新推荐文章于 2022-11-23 10:59:11 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 技术专栏 文章标签： float struct fp file 任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxfigo/article/details/4314472
版权

附录A  EBE-CG法主程序

/* FemPar.c

  Written by XiaoFei,college of mathematics science and computing technology,CSU,2009-5  */

#include<stdio.h>

#include<malloc.h>

#include"mpi.h"

#define PROCNO 4

typedef struct

{

    float Pos[2];

    int Local;

    int Type;

}NodeType;

typedef struct

{

    int Vertex[3];

}ElementType;

NodeType *Node;

ElementType *Element;

int *Shared,MaxCommon,Common[PROCNO],*Neighbours[PROCNO];

int ProcNo,ProcID,Nodes,Elements,IntNodes,IBNodes;

float *Buf;

 

float InnerProduct(float *A1,float *A2,float *B1,float *B2)

{

    int I;

    float IP=0.0,IPTocal;

    for(I=0;I<IntNodes;I++)

        IP+=A1[I]*B1[I];

    for(I=0;I<IBNodes;I++)

        IP+=(A2[I]*B2[I])/Shared[I];

    MPI_Allreduce(&IP,&IPTocal,1,MPI_FLOAT,MPI_SUM,MPI_COMM_WORLD);

    return(IPTocal);

}

void Update(float *A)

{

    int I,J;

    MPI_Status Status;

    for(I=0;I<PROCNO;I++)

    {

        for(J=0;J<Common[I];J++)

            Buf[J]=A[Node[Neighbours[I][J]].Local];

        if(Common[I]>0)

            MPI_Send(&Buf[0],Common[I],MPI_FLOAT,I,10,MPI_COMM_WORLD);

    }

    for(I=0;I<PROCNO;I++)

    {

        if(Common[I]>0)

            MPI_Recv(&Buf[0],Common[I],MPI_FLOAT,I,10,MPI_COMM_WORLD,&Status);

        for(J=0;J<Common[I];J++)

            A[Node[Neighbours[I][J]].Local]+=Buf[J];

    }

}

int CG(float **Ap,float **As,float **Bp,float *Fp,float *Fs,float *Vp,float *Vs)

{

    float *Rp,*Rs,*Pp,*Ps,*Qp,*Qs,GammaOld,GammaNew,Tau,Alpha,Beta,Tol=1.0e-4;

    int I,J,K,KMax=250;

    Pp=(float*)malloc(IntNodes*sizeof(float));

    Ps=(float*)malloc(IBNodes*sizeof(float));

    Qp=(float*)malloc(IntNodes*sizeof(float));

    Qs=(float*)malloc(IBNodes*sizeof(float));

    Rp=(float*)malloc(IntNodes*sizeof(float));

    Rs=(float*)malloc(IBNodes*sizeof(float));

    Update(Fs);

    for(I=0;I<IntNodes;I++)

        Pp[I]=Rp[I]=Fp[I];

    for(I=0;I<IBNodes;I++)

        Ps[I]=Rs[I]=Fs[I];

    GammaNew=InnerProduct(Rp,Rs,Rp,Rs);

    if(GammaNew<Tol*Tol)

        return(1);

    if(ProcID==0)

        printf("Gamma = %f/n",GammaNew);

    for(K=0;K<KMax;K++)

    {

        for(I=0;I<IntNodes;I++)

        {

            for(J=0,Qp[I]=0.0;J<IntNodes;J++)

                Qp[I]+=Ap[I][J]*Pp[J];

            for(J=0;J<IBNodes;J++)

                Qp[I]+=Bp[I][J]*Ps[J];

        }

        for(I=0;I<IBNodes;I++)

        {

            for(J=0,Qs[I]=0.0;J<IntNodes;J++)

                Qs[I]+=Bp[I][J]*Pp[J];

            for(J=0;J<IBNodes;J++)

                Qs[I]+=As[I][J]*Ps[J];

        }

        Update(Qs);

        Tau=InnerProduct(Pp,Ps,Qp,Qs);

        Alpha=GammaNew/Tau;

        for(I=0;I<IBNodes;I++)

        {

            Vp[I]+=Alpha*Pp[I];

            Rp[I]-=Alpha*Qp[I];

        }

        for(I=0;I<IBNodes;I++)

        {

            Vs[I]+=Alpha*Ps[I];

            Rs[I]-=Alpha*Qs[I];

        }

        GammaOld=GammaNew;

        GammaNew=InnerProduct(Rp,Rs,Rp,Rs);

        if(ProcID==0)

            printf("Gamma = %f (K = %d)/n",GammaNew,K);

        if(GammaNew<Tol*Tol)

            return(1);

        Beta=GammaNew/GammaOld;

        for(I=0;I<IntNodes;I++)

            Pp[I]=Rp[I]+Beta*Pp[I];

        for(I=0;I<IBNodes;I++)

            Ps[I]=Rs[I]+Beta*Ps[I];

    }

    return(0);

}

float BC(float X,float Y)

{

    return(X+Y);

}

 

main(int argc,char** argv)

{

    FILE *InFile,*OutFile;

    char FileName[40];

    int I,J,K,II,JJ;

    float **Ap,**Bp,**As,*Fp,*Fs,*Vp,*Vs;

    float SLoc[3][2],TwoA,Area,Gr0[3],Gr1[3],StiffJI;

 

    MPI_Init(&argc,&argv);

    MPI_Comm_rank(MPI_COMM_WORLD,&ProcID);

    MPI_Comm_size(MPI_COMM_WORLD,&ProcNo);

    if(ProcNo!=PROCNO)

    {

        printf("Unexpected number of processors./n");

        MPI_Abort(MPI_COMM_WORLD,-1);

    }

    if(ProcID<10)

        sprintf(FileName,"Data0%d.In",ProcID);

    else

        sprintf(FileName,"Data%d.In",ProcID);

    InFile=fopen(FileName,"r");

    fscanf(InFile,"%d%d",&Nodes,&Elements);

   

    Node=(NodeType*)malloc(Nodes*sizeof(NodeType));

    for(I=0,IntNodes=0,IBNodes=0;I<Nodes;I++)

    {

        fscanf(InFile,"%f%f%d",&Node[I].Pos[0],&Node[I].Pos[1],&Node[I].Type);

        if(Node[I].Type==1)

            Node[I].Local=IntNodes++;

        else if(Node[I].Type>1)

           Node[I].Local=IBNodes++;

        else

           Node[I].Local=-1;

    }

    Shared=(int*)malloc(IBNodes*sizeof(int));

    for(I=0,IBNodes=0;I<Nodes;I++)

        if(Node[I].Type>1)

            Shared[IBNodes++]=Node[I].Type;

    Element=(ElementType*)malloc(Elements*sizeof(ElementType));

    for(I=0;I<Elements;I++)

        fscanf(InFile,"%d%d%d",&Element[I].Vertex[0],&Element[I].Vertex[1],&Element[I].Vertex[2]);

    MaxCommon=0;

    for(I=0;I<PROCNO;I++)

    {

        fscanf(InFile,"%d",&Common[I]);

        if(Common[I]>MaxCommon)

            MaxCommon=Common[I];

        if(Common[I]>0)

            Neighbours[I]=(int*)malloc(Common[I]*sizeof(int));

        for(J=0;J<Common[I];J++)

            fscanf(InFile,"%d",&Neighbours[I][J]);

    }

    Buf=(float*)malloc(MaxCommon*sizeof(float));

    fclose(InFile);

    printf("ProcID = %d,IntNodes = %d,IBNodes = %d/n",ProcID,IntNodes,IBNodes);

    Ap=(float**)calloc(IntNodes,sizeof(float*));

    for(I=0;I<IntNodes;I++)

        Ap[I]=(float*)calloc(IntNodes,sizeof(float));

    Bp=(float**)calloc(IBNodes,sizeof(float*));

    for(I=0;I<IntNodes;I++)

        Bp[I]=(float*)calloc(IntNodes,sizeof(float));

    As=(float**)calloc(IBNodes,sizeof(float*));

    for(I=0;I<IBNodes;I++)

        As[I]=(float*)calloc(IBNodes,sizeof(float));

    Fp=(float*)calloc(IntNodes,sizeof(float));

    Fs=(float*)calloc(IBNodes,sizeof(float));

    Vp=(float*)calloc(IntNodes,sizeof(float));

    Vs=(float*)calloc(IBNodes,sizeof(float));

    for(K=0;K<Elements;K++)

    {

        SLoc[0][0]=Node[Element[K].Vertex[0]].Pos[0];

        SLoc[1][0]=Node[Element[K].Vertex[1]].Pos[0];

        SLoc[2][0]=Node[Element[K].Vertex[2]].Pos[0];

        SLoc[0][1]=Node[Element[K].Vertex[0]].Pos[1];

        SLoc[1][1]=Node[Element[K].Vertex[1]].Pos[1];

        SLoc[2][1]=Node[Element[K].Vertex[2]].Pos[1];

        TwoA=SLoc[0][0]*(SLoc[1][1]-SLoc[2][1])+

             SLoc[1][0]*(SLoc[2][1]-SLoc[0][1])+

             SLoc[2][0]*(SLoc[0][1]-SLoc[1][1]);

        Area=0.5*TwoA;

        Gr0[0]=(SLoc[1][1]-SLoc[2][1])/TwoA;

        Gr0[1]=(SLoc[2][1]-SLoc[0][1])/TwoA;

        Gr0[2]=(SLoc[0][1]-SLoc[1][1])/TwoA;

        Gr0[0]=-(SLoc[1][0]-SLoc[2][0])/TwoA;

        Gr0[1]=-(SLoc[2][0]-SLoc[0][0])/TwoA;

        Gr0[2]=-(SLoc[0][0]-SLoc[1][0])/TwoA;

        for(J=0;J<3;J++)

        {

            JJ=Element[K].Vertex[J];

            if(Node[JJ].Type==1)

                for(I=0;I<3;I++)

                {

                    II=Element[K].Vertex[I];

                    StiffJI=Area*(Gr0[I]*Gr0[J]+Gr1[I]*Gr1[J]);

                    if(Node[II].Type==1)

                        Ap[Node[JJ].Local][Node[II].Local]+=StiffJI;

                    else

                        if(Node[II].Type>1)

                            Bp[Node[JJ].Local][Node[II].Local]+=StiffJI;

                        else

                            if(Node[II].Type==0)

                            Fp[Node[JJ].Local]-=BC(Node[II].Pos[0],Node[II].Pos[1])*StiffJI;

                }

            else

                if(Node[JJ].Type>1)

                    for(I=0;I<3;I++)

                    {

                        II=Element[K].Vertex[I];

                        StiffJI=Area*(Gr0[I]*Gr0[J]+Gr1[I]*Gr1[J]);

                        if(Node[II].Type>1)

                            As[Node[JJ].Local][Node[II].Local]+=StiffJI;

                        else

                            if(Node[JJ].Type==0)

                            Fs[Node[JJ].Local]-=BC(Node[II].Pos[0],Node[II].Pos[1])*StiffJI;

                    }

        }

    }

    CG(Ap,As,Bp,Fp,Fs,Vp,Vs);

    for(I=0;I<Nodes;I++)

        if(Node[I].Type==1)

            printf(" %f %f %f/n",Node[I].Pos[0],Node[I].Pos[1],Vp[Node[I].Local]);

        else

            if(Node[I].Type>1)

                printf(" %f %f %f/n",Node[I].Pos[0],Node[I].Pos[1],Vs[Node[I].Local]);

    MPI_Finalize();

}

 

 

  

 

 

 

 

附录B  任务分配预处理程序

#include<stdio.h>

#define FILENAME "mesh.txt"

#define PROCNO 4

typedef struct{

float Pos[2]; //位置坐标

int GlobalDOF;

int LocalNode;

int Type;

}NodeType;

typedef struct{

    int Vertex[3];

}ElementType;

NodeType* Node;

ElementType* Element;

int PartSize[PROCNO],*PartE[PROCNO],*PartN[PROCNO];

 

main(int argc,char** argv)

{

    FILE *InFile,*OutFile;

    int Nodes,Elements,I,J,K,V,NodeCounter[PROCNO],Common[PROCNO];

    char FileName[40];

   

    InFile=fopen(FILENAME,"r");

//读入节点信息

    fscanf(InFile,"%d",&Nodes);//节点数目

    Node=(NodeType*)malloc(Nodes*sizeof(NodeType));

    for(I=0;I<PROCNO;I++)

        PartN[I]=(int*)malloc(Nodes*sizeof(int));

    for(I=0;I<Nodes;I++)

    {

      fscanf(InFile,"%d%f%f",&Node[I].GlobalDOF,&Node[I].Pos[0],&Node[I].Pos[1]);

        //读入节点GlobalDOF，坐标，

        Node[I].Type=0;

        //初始化节点符号，<0表示边界

    }

//读入单元信息

    fscanf(InFile,"%d",&Elements); //单元数目

    Element=(ElementType*)malloc(Elements*sizeof(ElementType));

    for(I=0;I<PROCNO;I++)

    {

        PartE[I]=(int*)malloc(Elements*sizeof(int));

        PartSize[I]=0;

    }

    for(I=0;I<Elements;I++)

        fscanf(InFile,"%d%d%d",&Element[I].Vertex[0],&Element[I].Vertex[1],&Element[I].Vertex[2]);

        //读入单元的三个vertex

//构造PartE

    for(J=0;J<Elements;J++)

    {

        fscanf(InFile,"%d",&I);

        PartE[I][PartSize[I]++]=J;

    }

    fclose(InFile);

//关闭文件

    for(I=0;I<PROCNO;I++)

    {

        NodeCounter[I]=0;

        for(J=0;J<Nodes;J++)

        {

            Node[J].LocalNode=-1;

            PartN[I][J]=0;

        }//初始化

//构造PartN

        for(J=0;J<PartSize[I];J++)

        {

            for(K=0;K<3;K++)

            {

                V=Element[PartE[I][J]].Vertex[K];

                if(Node[V].LocalNode==-1)

                    Node[V].LocalNode=NodeCounter[I]++;

                if(Node[V].GlobalDOF>-1&&PartN[I][V]==0)

                {

                    Node[V].Type++;

                    PartN[I][V]=1;

                }

            }

        }

    }

    for(I=0;I<PROCNO;I++)

    {

        if(I<10)

            sprintf(FileName,"Data0%d.In",I);

        else

            sprintf(FileName,"Data%d.In",I);

        OutFile=fopen(FileName,"w");

        fprintf(OutFile," %d %d/n",NodeCounter[I],PartSize[I]);

        NodeCounter[I]=0;

        for(J=0;J<Nodes;J++)

            Node[J].LocalNode=-1;

        for(J=0;J<PartSize[I];J++)

        {

            for(K=0;K<3;K++)

            {

                V=Element[PartE[I][J]].Vertex[K];

                if(Node[V].LocalNode==-1)

                {

                    Node[V].LocalNode=NodeCounter[I]++;

                    fprintf(OutFile," %f %f %d/n",Node[V].Pos[0],Node[V].Pos[1],Node[V].Type);

                }

            }

        }

        for(J=0;J<PartSize[I];J++)

        {

            for(K=0;K<3;K++)

            {

                V=Element[PartE[I][J]].Vertex[K];

                fprintf(OutFile," %d",Node[V].LocalNode);

            }

            fprintf(OutFile,"/n");

        }

        for(K=0;K<PROCNO;K++)

        {

            Common[K]=0;

            if(I!=K)

                for(J=0;J<Nodes;J++)

                    if(PartN[I][J]>0&&PartN[K][J]>0)

                        Common[K]++;

        }

        for(K=0;K<PROCNO;K++)

        {

            fprintf(OutFile," %d/n",Common[K]);

            if(Common[K]>0)

            {

                for(J=0;J<Nodes;J++)

                    if(PartN[I][J]>0&&PartN[K][J]>0)

                        fprintf(OutFile," %d",Node[J].LocalNode);

                    fprintf(OutFile,"/n");

            }

        }

        fclose(OutFile);

    }

}

xxfigo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
cg法matlab代码-FEA-compare:有限元比较
05-20
cg法matlab代码概述 这是来自FEA软件手动填充的*.profiles 。 它还具有HTML格式（快速且正确地呈现来自先前提交的html表），（有点慢，Firefox出现问题，通常是当前提交），并且第一行和Feature列已修复，以便于表浏览。 表中的配置文件按填充键的数量排序。 个人资料格式 配置文件逐行读取。 冒号:之前的任何字符串均被视为键，其余部分直到该行的末尾均被视为值。 没有冒号的行将被忽略，注释应以行的开头以井号#开头。 main-keys.txt文件包含要首先列出的键，然后列出所有配置文件中的所有其他键。 键始终带有冒号，而表组名称则不带冒号（为方便起见，它们缩进了四个空格）。 使用generate-comparison.py从配置文件生成表，您将需要安装org-ruby gem将其转换为HTML格式（在Ubuntu linux中使用sudo gem install org-ruby来安装此gem）。 它还将发出tmp.wiki以便您可以更新相关页面。 贡献 免费填写以贡献自己的力量！ 仍然有很多代码没有与表进行比较，例如：NgSolve，CalculiX和Sal
EBE-PCG算法
12-09
EBE-PCG算法在有限元并行计算中的应用研究，一个并行算法研究论文，供大家参考
有限元python编程流行吗_Python进行有限元分析
weixin_39928844的博客
12-06 1115
本博客主要是来讲述采用Python语言，利用直接刚度法，来编写求解《有限元方法基础教程》(第五版) 的例题2.1。(也许有的人认为商业软件已经和普及了，没有 必要再自己进行编程了，但是龙猪在这里建议大家还是去了解一下有限元的原理，这样对我们深入了解软件的原理和进一步的应用会有很大的帮助) 可参考该作者的文章：《有限元分析基础教程》(曾攀)笔记一-二维杆单元有限元程序(基于Python) - Sim...
基于以太坊区块链的物联网/IoT设备管理【论文及源码】
跨链技术践行者
07-31 1410
本文介绍一个利用以太坊区块链管理物联网IoT设备的身份识别、 验证和声誉的IoT设备管理系统。该系统使用Web界面在以太坊智能合约 中注册物联网设备，并通过密码学签名消息验证Iot设备对平台的 使用权。 1、区块链物联网设备管理系统的基本概念 物联网/IoT设备的标识： 通过默克尔树（Merkle Tree）的利用，无需暴露设备的私有属性即可完成 IoT设备的注册。使用公钥（或其衍生表示）作为IoT设备的标识ID。 物联网/IoT设备的消息签名与验证： 系统中的每个消息都需要由发送端的IoT设备.
基于MiniTest的小程序自动化测试
清雨染墨衣
11-23 3566
minium 是为小程序专门开发的自动化框架。使用 minium 可以进行小程序 UI 自动化测试, 但是 minium 的功能不止于仅仅是 UI 自动化, 甚至可以使用 minium 来进行函数的 mock, 可以直接跳转到小程序某个页面并设置页面数据, 做针对性的全面测试, 这些都得益于我们开放了部分小程序 API 的能力。除此之外，小程序有部分组件使用了系统原生的组件，对于这部分的组件，我们也基于 uiautomator 和 wda 做了补充。
【愚公系列】2022年08月 微信小程序-view生成分享图片
时光隧道
08-28 9758
微信小程序并不支持view直接转绘到画布上，想要实现海报功能必须通过以下4个步骤：项目结构图： 1、dialogModal 2、painter lib painter部分 3、shareBox 2.组件的使用 3.效果
基于单元级矩阵分解的EBE-PCG算法及其在网络机群并行环境上的实现 (2003年)
06-13
基于EBE策略,讨论求解大型线性方程组CG方法及PCG方法的并行计算。在不显式形成总刚度阵的情况下利用单元级矩阵的Cholesky分解构造总刚度阵的近似,形成预条件矩阵,提出了求解大型线性方程组的EBE-PCG并行算法,并讨论...
java8源码-ebe-shop:基于SpringBoot+Shiro+Layui构建的商城商店系统，演示地址：http://tysxquan
06-04
ebe-shop是一款简单美观高效的商城系统，使用SpringBoot、Shiro架构，数据持久化层为Mybatis+Mybatis-Plus构建及Layui+Thymeleaf模板引擎搭建的前端视图模型，适合新零售、商店、连锁商店等系统使用。 技术选型 核心...
论文研究 - 从课程实施角度看中学生的团体咨询技术和风险行为管理
05-29
采用观察和访谈研究方法进行调查。 使用半结构化观察指南和半结构化面试指南收集数据。 通过非概率抽样技术，选择了雅温得政府双语高中（Etoug-ebe）的辅导员进行研究。 遵循研究的主要目标，对收集的数据进行了...
940cac72-6ebe-48e4-98f9-77a421d8fe5 (2).zip
11-12
940cac72-6ebe-48e4-98f9-77a421d8fe5 (2).zip
ＶＳ２００５　error PRJ0003 : 生成 cmd.exe 时出错
热门推荐
肖飞figo的云计算专栏
11-21 1万+
　　一直被一个问题所困扰，那就是运行CLR—Windows窗体应用程序的时候，即使什么代码也不写，直接编译运行也会报错：“error PRJ0003 : 生成 cmd.exe 时出错” 。　　一直在查找资料，看到是因为ＶＳ２００５的环境变量设置不对，应该如下解决：solution: tools=> Options => Projects and Solutions -> VC++ Dire
在MyEclipse8.6中设置jQuery自动提示
肖飞figo的云计算专栏
01-14 8728
MyEclipse8.6是目前J2EE开发中高版本的开发工具，比起一般的Eclipse她有更多的功能！毕竟是商业版本嘛，绝对J2EE是开发神器！ 但是MyEclipse8.6默认是没有开启jQuery提示的，怎样才能开启提示呢
error 1718: was rejected by digital signature policy
肖飞figo的云计算专栏
05-12 3210
我在新装的windows server 2003上面安装VNware（vmware-server-2.0.2-203138.exe）的时候出现了以下提示：Error 1718 File C:/WINDOWS/Installer/8f6a93f3.msp was rejected by digital signature policy.以下是问题分析和解决方案：
C++ 托管扩展语法升级清单
肖飞figo的云计算专栏
12-08 1950
本主题列出了 C++ 托管扩展和新的 C++ 语法之间的语法差异。详情参见MSDN中的C++/CLI 迁移入门更新 C++ 托管扩展代码 移除 #using 。（现在，默认情况下引用此程序集。） 将 __gc class 替换为 ref class。 将 __gc struct 替换为 ref
有关UNICODE、ANSI字符集和相关字符串操作的总结！
肖飞figo的云计算专栏
11-06 1623
  最进一直使用VS2005进行VC++的编程，经常遇到一个错误：error C2440: = : cannot convert from const char [23] to LPCWSTR查了好多资料最终才意识到原来是ＵＮＩＣＯＤＥ字符集的问题，现在找来资料看看，希望能帮助像我一样的菜鸟。Q  UNICODE字符串如何显示  A  如果程序定义了_UNICODE宏直接用
Microsoft.NET Framework 全面开源
肖飞figo的云计算专栏
01-21 1476
期待已久的.NET Framework终于在本周开源了，微软在MS-RL协议下终于公开了.NET Framework源代码，我们只可以自由查看，不允许直接进行修改。第一批开放的源代码包括：.NET基本类库：System，System.CodeDom，System.Collections,System.ComponentModel, System.Diagnostics, System.Draw
WPF,你准备好了吗？
肖飞figo的云计算专栏
01-21 1394
要赢得世界，必须在恰当的时间做出恰当的事。这一点，微软做到了。历经微软DOS，Win 31, Windows 95, Windows 98, Windows 2000, Windows XP, 一路走来，一次比一次热闹，一个比一个精彩、炫丽。Windows Vista的宣传更是轰轰烈烈，喧嚣日上。初见Windows Vista,都会被它的酷炫界面所吸引，哇！原来Windows也可与Mac一样酷、一
如何在MFC里写自己的自定义消息
肖飞figo的云计算专栏
11-07 1340
Windows 应用程序所要做的每项工作几乎都是基于消息(Message Based)处理的， Windows 系统消息分为常用 Windows 消息，控件通知消息和命令消息。然而，有时 我们需要定义自己的消息来通知程序什么事情发生了，这就是用户自定义消息。ClassWizard 并没有提供增加用户自定义消息的功能，所以要使用用户自定义消息，必须手工编写代码。然后 ClassWizard 才可以象
printk("%p:%d-------jc--------- \n",oskb->_skb_refdst ,__LINE__); 打印出来的目标地址为00000000ebe64cfa，代表什么意思
最新发布
11-08
这个目标地址00000000ebe64cfa是一个内存地址，它指向一个物理内存位置，该位置存储了一个数据或对象。在这个特定的情况下，这个地址指向一个名为`oskb->_skb_refdst`的变量或对象。这个变量或对象的值是一个指针，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值