精华内容
下载资源
问答
  • 华为hcip认证里面的NAS 优缺点一定要了解的,网络附加存储(NAS:Network Attached Storage)是一种采用直接与网络介质相连的设备实现数据存储的机制。一般NAS支持通过CIFS(Common Internet File System)、NFS...

    华为hcip认证里面的NAS 优缺点一定要了解的,网络附加存储(NAS:Network Attached Storage)是一种采用直接与网络介质相连的设备实现数据存储的机制。一般NAS支持通过CIFS(Common Internet File System)、NFS(Network File System)、FTP(File Transfer Protocol)和HTTP(Hypertext transfer protocol)等协议访问共享的文件。

     

    NAS存储的特点

    1.NAS存储内置专门用于数据存储的简化操作系统和网络协议,可以直接挂接到网络上,安装十分方便。

    2. NAS独立于操作系统平台,可以支持Windows、UNIX、Linux等不同操作系统。

    3.管理员可以通过访问共享目录的方式存储数据。

    4. NAS存储支持快照技术,对文件系统定时拍快照,同时NAS支持NDMP协议的,使NAS的数据备份和还原更快速,方便,且不占用网络资源。

    5.用户可以为不同的目录设置不同的空间大小和文件个数限制,便于存储资源的有效利用。

     

    SAN和NAS的比较

    SAN和NAS适合的应用不同。SAN是传统的DAS技术的发展延续,是适合大量的数据块访问方式的网络存储技术,信息主要是以块方式存储及管理的应用。SAN技术的核心是SAN交换机,SAN交换机是存储系统和主机系统之间的桥梁。尽管SAN交换机上也配置CPU和CACHE,也可以具有自我管理、自我配置等智能软件,但其主要作用还是作为数据交换通道。SAN技术经过几年的发展已经非常成熟,SAN技术吸收传统通道技术和传统网络技术的优势,因此具有诸如高速、低延迟、高数据一致性、大数据传输、路由管理、广泛连接性、远距离支持、灵活管理等优势。

    NAS是传统网络文件服务器技术的发展延续,是专用的网络文件服务器,是代替传统网络文件服务器市场的新技术、新产品。网络文件服务器技术是建立在网络技术发展成熟基础之上的。因此它的访问协议是通用的TCP/IP,今天的NAS产品也是基于TCP/IP协议的文,华为hcip认证里面的NAS 优缺点一定要了解的

    展开全文
  • 论敏捷开发的优缺点

    万次阅读 2017-06-20 14:39:52
    近期试用了一下华为最新推出的项目管理工具-华为软件开发云,接触了敏捷开发,产生一些想法。以下是使用体验,仅供同行们参考。 一、敏捷开发技术的几个特点和优势: 1.个体和交互胜过过程和工具 2....

    踏入软件开发行列时间不算短了,也使用过很多项目管理软件和方法,但是在使用过程中多多少少都会遇到一些问题吧,同行们或多或少也会有相应的体验。近期试用了一下华为最新推出的项目管理工具-华为软件开发云,接触了敏捷开发,产生一些想法。以下是使用体验,仅供同行们参考。

    一、敏捷开发技术的几个特点和优势:

    1.个体和交互胜过过程和工具

    2.可以工作的软件胜过面面俱到的文档

    3.客户合作胜过合同谈判

    4.响应变化胜过遵循计划

    二、敏捷开发技术的12个原则:

    1.我们最优先要做的是通过尽早的、持续的交付有价值的软件来使客户满意。

    2.即使到了开发的后期,也欢迎改变需求。

    3.经常性地交付可以工作的软件,交付的间隔可以从几周到几个月,交付的时间间隔越短越好。

    4.在整个项目开发期间,业务人员和开发人员必须天天都在一起工作。

    5.围绕被激励起来的个人来构建项目。

    6.在团队内部,最具有效果并且富有效率的传递信息的方法,就是面对面的交谈。

    7.工作的软件是首要的进度度量标准。

    8.敏捷过程提倡可持续的开发速度。

    9.不断地关注优秀的技能和好的设计会增强敏捷能力。

    10.简单使未完成的工作最大化。

    11.最好的构架、需求和设计出自于自组织的团队。

    12.每隔一定时间,团队会在如何才能更有效地工作方面进行反省,然后相应地对自己的行为进行调整。

    三、敏捷开发技术的适用范围

    1.项目团队的人数不能太多

    2.项目经常发生变更

    3.高风险的项目实施

    4.开发人员可以参与决策

    根据以上三点,大体可以总结出:

    优势:

    敏捷确实是项目进入实质开发迭代阶段,用户很快可以看到一个基线架构版的产品。敏捷注重市场快速反应能力,也即具体应对能力,客户前期满意度高。

    劣势:

    但敏捷注重人员的沟通,忽略文档的重要性,若项目人员流动大太,又给维护带来不少难度,特别项目存在新手比较多时,老员工比较累。

    需要项目中存在经验较强的人,要不大项目中容易遇到瓶颈问题。

    结合华为软件开发云,他们提供了两种项目创建方法:Scrum和Scrum精简,可以结合自己的不同习惯,选择合适自己团队的方法,这点还是不错的。


    同时,华为软件开发云,在文档和百科管理上,也增加了自己的特色,有效避免传统敏捷开发的劣势。大家不妨试用一下,后续有什么建议和想法,欢迎一起探讨。

    展开全文
  • 华为liteos内存管理源码以及架构分析 ...liteos内存分配策略的优缺点 liteos内存分配代码在平时工作中帮助解决bug华为liteos内存管理源码以及架构分析本文主要从源码层面讲解华为针对物联网的一个小型操作系统liteos的

    华为liteos内存管理源码以及架构分析

    本文主要从源码层面讲解华为针对物联网的一个小型操作系统liteos的内存管理方式:

    • liteos内存管理概要
    • liteos内存管理结构图
    • liteos内存管理源码los_memory.c源码分析
    • liteos内存分配策略的优缺点
    • liteos内存分配代码,在平时工作中帮助解决bug

    liteos内存管理概要

    一般对于操作系统来说,主要有几个必要核心的基础模块,内存管理,任务调度,任务之间的通信和互斥。这几个是一个操作系统最核心的模块其次比较重要的就是文件系统,网络协议栈等一些比较重要的模块,再下来就是操作系统根据各种类型的设备定义的一些驱动的框架,比如字符设备,块设备,等各种类型的设备的管理框架,再具体下来就是具体的设备驱动程序这些是和具体的设备相关的。内存管理应该属于操作系统最基础的模块了,因为其他的模块基本都会使用该模块的接口去分配和释放内存。liteos也不例外,所以本文主要讲解liteos的内存管理。

    牵扯到的主要数据结构

    主要数据结构如下,后面再从代码层面依次详细讲解:

    typedef struct
    {
        VOID *pPoolAddr;/*内存池起始地址*/
        UINT32 uwPoolSize;     /**<内存池大小*/
    } LOS_MEM_POOL_INFO;

    LOS_MEM_POOL_INFO该结构体是内存池的起始地址和内存池的大小,位于内存池的开头,后面会有结构图。

    typedef struct tagLOS_MEM_DYN_NODE
    {
        LOS_DL_LIST stFreeNodeInfo; /**<没有使用的内存节点链表*/
        struct tagLOS_MEM_DYN_NODE *pstPreNode; /*前一个内存节点*/
        UINT32 uwSizeAndFlag; /*当前节点的管理内存的大小,最高位表示内存是否已经被分配*/
    }LOS_MEM_DYN_NODE;

    LOS_MEM_DYN_NODE该结构体内存管理的基本单元,每分配一次内存就是在找大小合适的节点,没有使用的内存也是通过这样的node一个个组织起来的。

    typedef struct LOS_DL_LIST
    {
        struct LOS_DL_LIST *pstPrev; /*指向链表的前一个节点*/
        struct LOS_DL_LIST *pstNext; /*指向链表的后一个节点*/
    } LOS_DL_LIST;

    LOS_DL_LIST这个是一个双向链表,用来阻止没有使用的内存。

    typedef struct
    {
        LOS_DL_LIST stListHead[OS_MULTI_DLNK_NUM];//链表数组
    } LOS_MULTIPLE_DLNK_HEAD;

    注意: LOS_MULTIPLE_DLNK_HEAD该结构体是内存管理模块一个比较重要的结构体,该数组中的每一个元素都是一个链表,主要用来管理没有使用的内存,并且按照2的幂次方大小范围管理,每次分配的内存的是否都是找到该数组中合适的链表,然后找到链表中合适的元素。

    liteos内存管理结构图

    这里写图片描述

    上次中的第一行是整个内存池结构,第二行和第三行分别对应第一行蓝色线放大对应的具体结构,笔直的红色线代表sFreeNodeInfo是数组中某一个链表的一个node,用来管理没有使用的内存,具体是那个元素我们在后面的代码中具体分析。

    红色笔话的线以及标记的uwSizeAndFlag表示箭头对应的长度,注意这个flag中最高位表示该节点是否使用,liteos就是使用这样的节点表示一个内存块。然后再list数组中管理没有使用的内存。

    liteos内存管理源码los_memory.c源码分析

    内存池的初始化

    UINT32 LOS_MemInit(VOID *pPool, UINT32  uwSize)
    {
        LOS_MEM_DYN_NODE *pstNewNode = (LOS_MEM_DYN_NODE *)NULL;
        LOS_MEM_DYN_NODE *pstEndNode = (LOS_MEM_DYN_NODE *)NULL;
        LOS_MEM_POOL_INFO *pstPoolInfo = (LOS_MEM_POOL_INFO *)NULL;
        UINTPTR uvIntSave;
        LOS_DL_LIST *pstListHead = (LOS_DL_LIST *)NULL;
    
        if ((pPool == NULL) || (uwSize < (OS_MEM_MIN_POOL_SIZE)))
        {
            return OS_ERROR;
        }
    
    
        pstPoolInfo = (LOS_MEM_POOL_INFO *)pPool;
        pstPoolInfo->pPoolAddr = pPool;//pool的起始地址就是内存数组的起始地址
        pstPoolInfo->uwPoolSize = uwSize;//pool的大小就是内存数组的大小
        LOS_DLnkInitMultiHead(OS_MEM_HEAD_ADDR(pPool));//内存地址除去poolinfo开始DLINK_HEAD地址,也就是list数组的起始地址
        pstNewNode = OS_MEM_FIRST_NODE(pPool);//除去poolinfo 和DLINK_HEAD的list数组开始第一个node
        //大小除去第info和list数组和第一个node剩下的大小
        pstNewNode->uwSizeAndFlag = ((uwSize - ((UINT32)pstNewNode - (UINT32)pPool)) - OS_MEM_NODE_HEAD_SIZE);
        pstNewNode->pstPreNode = (LOS_MEM_DYN_NODE *)NULL;
        pstListHead = OS_MEM_HEAD(pPool, pstNewNode->uwSizeAndFlag);//找出list中的第log(size)-4个节点,这里是数学中的对数
        if (NULL == pstListHead)
        {
            printf("%s %d\n", __FUNCTION__, __LINE__);
            return OS_ERROR;
        }
    
        LOS_ListTailInsert(pstListHead,&(pstNewNode->stFreeNodeInfo));
        pstEndNode = (LOS_MEM_DYN_NODE *)OS_MEM_END_NODE(pPool, uwSize);//最后一个node
        (VOID)memset(pstEndNode, 0 ,sizeof(*pstEndNode));
        pstEndNode->pstPreNode = pstNewNode;
        pstEndNode->uwSizeAndFlag = OS_MEM_NODE_HEAD_SIZE;
        OS_MEM_NODE_SET_USED_FLAG(pstEndNode->uwSizeAndFlag);//标记为已经使用,这个可以防止越界,后面会用到。
        osMemSetMagicNumAndTaskid(pstEndNode);
    
        return LOS_OK;
    }

    该函数的参数可以看成是一个数组的其实地址和数组的大小,事实上liteos中这两个参数确实是一个数组,该数组就是被管理的内存池。其实上面的那个图的第一行就是表示这个数组,元素的关系就是图上的关系。主要做了一下几个重要操作
    1,分配和初始化pstPoolInfo
    2,数组开头跳过pstPoolInfo的大小分配和初始化链表数组,
    3,跳过pstPoolInfo和链表数组开始的是第一个内存管理节点pstNewNode
    4,在链表数组中找到合适的位置将pstNewNode插入链表。
    5,数组的末尾也是一个内存管理节点pstEndNode,所以可以分配的初始
    化好之后,可以分配的内存就位于pstNewNode和pstEndNode之间。
    上面五个步骤第三步是很关键的,下面详细详解。
    第三步首先调用OS_MEM_HEAD这个宏定义函数,在list数组中找到合适的链表,然后将pstNewNode插入链表。

    宏定义依次为:

    #define OS_MEM_HEAD(pPool, uwSize) OS_DLnkHead(OS_MEM_HEAD_ADDR(pPool), uwSize)
    
    //在内存池数组开头跳过LOS_MEM_POOL_INFO得到list数组结构体的地址
    #define OS_MEM_HEAD_ADDR(pPool) ((VOID *)((UINT32)(pPool) + sizeof(LOS_MEM_POOL_INFO)))
    
    #define OS_DLnkHead                         LOS_DLnkMultiHead
    
    
    LOS_DL_LIST *LOS_DLnkMultiHead(VOID *pHeadAddr, UINT32 uwSize)
    {
        LOS_MULTIPLE_DLNK_HEAD *head = (LOS_MULTIPLE_DLNK_HEAD *)pHeadAddr;
        UINT32 idx =  LOS_Log2(uwSize);//这里就不再贴代码里,这里只要求uSize的二进制表示法最高为1的为在第几位,如LOS_Log2(1024)=10,LOS_Log2(2047)=10
        if(idx > OS_MAX_MULTI_DLNK_LOG2)
        {
            return (LOS_DL_LIST *)NULL;
        }
    
        if(idx <= OS_MIN_MULTI_DLNK_LOG2)
        {
            idx = OS_MIN_MULTI_DLNK_LOG2;
        }
        //链表数组的第几个元素
        return head->stListHead + (idx - OS_MIN_MULTI_DLNK_LOG2);
    }

    上面这个函数中的LOS_Log2()是一个数学中的以2为底的对数函数,只不过下取整如:
    LOS_Log2(1024)结果为10,LOS_Log2(2047)也为10,但是LOS_Log2(2048)就是11,所以该函数也就是求解uwSize的二进制表示方式中1的最高位。
    所以也不难理解LOS_DLnkMultiHead函数就是在list数组中根据uwSize的大小找到一个合适的list,所以该list数组是按照2的指数倍一次组织内存的。所有没有使用的内存都使用该list数组来组织。
    求出合适的位置也就是找到了list之后,将pstNewNode插入list中,也就是
    LOS_ListTailInsert(pstListHead,&(pstNewNode->stFreeNodeInfo));这句代码。
    这样内存池的初始化基本就完成了。后面就可以分配内存使用了。其实就是在内存数组中找到合适的内存节点,

    内存分配

    VOID *LOS_MemAlloc (VOID *pPool, UINT32  uwSize)
    {
        VOID *pPtr = NULL;
        do
        {
            if ((pPool == NULL) || (uwSize == 0))
            {
                break;
            }
            //判断如果uwSize的最最高位为1直接跳出返回
            if (OS_MEM_NODE_GET_USED_FLAG(uwSize))
            {
                break;
            }
            //实际在内存池分配内存
            pPtr = osMemAllocWithCheck(pPool, uwSize);
        } while (0);
    
        return pPtr;
    }
    
    static inline VOID *osMemAllocWithCheck(VOID *pPool, UINT32  uwSize)
    {
        LOS_MEM_DYN_NODE *pstAllocNode = (LOS_MEM_DYN_NODE *)NULL;
        UINT32 uwAllocSize;
        //因为liteos是使用node节点管理内存的所以这一需要添加node结构体长度,然后四字节对齐。
        uwAllocSize = OS_MEM_ALIGN(uwSize + OS_MEM_NODE_HEAD_SIZE, OS_MEM_ALIGN_SIZE);
         //我们在上面说过没有使用的内存都在list数组中按照内存的大小以2的指数级插入链表管理的。
        pstAllocNode = osMemFindSuitableFreeBlock(pPool, uwAllocSize);
        if (pstAllocNode == NULL)
        {
            printf("[%s] No suitable free block, require free node size: 0x%x\n", __FUNCTION__, uwAllocSize);
            return NULL;
        }
        //如果找到的节点分配之后还可以分出一个节点,那么就将该节点分出来
        if ((uwAllocSize + OS_MEM_NODE_HEAD_SIZE + OS_MEM_ALIGN_SIZE) <= pstAllocNode->uwSizeAndFlag)
        {
            osMemSpitNode(pPool, pstAllocNode, uwAllocSize);
        }
        //从链表中删除该节点
        LOS_ListDelete(&(pstAllocNode->stFreeNodeInfo));
        osMemSetMagicNumAndTaskid(pstAllocNode);
        OS_MEM_NODE_SET_USED_FLAG(pstAllocNode->uwSizeAndFlag);
        OS_MEM_ADD_USED(OS_MEM_NODE_GET_SIZE(pstAllocNode->uwSizeAndFlag));
        //返回给用户的是用户可以使用的内存,所以这里需要跳过node
        return (pstAllocNode + 1);
    }

    上面关键的一个

    注意: osMemFindSuitableFreeBlock该函数是遍历我们的list数组找到根据大小找到合适的节点,正如前面所说,所有没有使用的内存都在该数组链表里面保存着。
    找到之后如果找到的节点还足够分出一个节点那么就将该节点分出来将剩下的分出来的节点挂入list数组

    分节点函数

    static inline VOID osMemSpitNode(VOID *pPool,
                                LOS_MEM_DYN_NODE *pstAllocNode, UINT32 uwAllocSize)
    {
        LOS_MEM_DYN_NODE *pstNewFreeNode = (LOS_MEM_DYN_NODE *)NULL;
        LOS_MEM_DYN_NODE *pstNextNode = (LOS_MEM_DYN_NODE *)NULL;
        LOS_DL_LIST *pstListHead = (LOS_DL_LIST *)NULL;
        //分出新的节点
        pstNewFreeNode = (LOS_MEM_DYN_NODE *)((UINT8 *)pstAllocNode + uwAllocSize);
        pstNewFreeNode->pstPreNode = pstAllocNode;
        pstNewFreeNode->uwSizeAndFlag = pstAllocNode->uwSizeAndFlag - uwAllocSize;
        pstAllocNode->uwSizeAndFlag = uwAllocSize;
        //新节点的下一个节点
        pstNextNode = OS_MEM_NEXT_NODE(pstNewFreeNode);
        pstNextNode->pstPreNode = pstNewFreeNode;
        /*判断新节点的下一个节点是否使用,如果没有使用那么将新节点和下一个节点合并,这也就是为什么在初始化的时候最后一个节点要标记为已经使用,还有就是我们可能多次的分配释放,所以下一个节点有可能是没有使用的,所以这里要添加判断*/
        if (!OS_MEM_NODE_GET_USED_FLAG(pstNextNode->uwSizeAndFlag))
        {
            LOS_ListDelete(&(pstNextNode->stFreeNodeInfo));
            osMemMergeNode(pstNextNode);
        }
        //根据大小在list数组中找到合适的list
        pstListHead = OS_MEM_HEAD(pPool, pstNewFreeNode->uwSizeAndFlag);
        if (NULL == pstListHead)
        {
            printf("%s %d\n", __FUNCTION__, __LINE__);
            return;
        }
        //将分出来的节点加入list
        LOS_ListAdd(pstListHead,&(pstNewFreeNode->stFreeNodeInfo));
    }
    

    以上就是内存的分配,当分配内存是首先从list数组中找到合适的node节点,如果该node节点管理的内存大于需要分配的内存,并且可以再分出一个节点,那么就将找到的节点分割,一部分是返回给分配的用户,一部分是没有使用的,然后看看这个没有使用的节点的下一个节点是否使用,如果没有那么将该节点和下一个节点合并,然后插入list数组,如果易已经使用,那么直接插入list数组。

    最后就是跳过分配的节点结构体返回用户可以使用的内存起始地址

    内存释放

    UINT32 LOS_MemFree(VOID *pPool, VOID *pMem)
    {
        UINT32 uwRet = LOS_NOK;
        UINT32 uwGapSize = 0;
        do
        {
            LOS_MEM_DYN_NODE *pstNode = (LOS_MEM_DYN_NODE *)NULL;
            if ((pPool == NULL) || (pMem == NULL))
            {
                break;
            }
            //字节对齐处理,由于有字节对齐分配,我们没有这里就不分析了
            uwGapSize = *((UINT32 *)((UINT32)pMem - 4));
            if (OS_MEM_NODE_GET_ALIGNED_FLAG(uwGapSize))
            {
                uwGapSize = OS_MEM_NODE_GET_ALIGNED_GAPSIZE(uwGapSize);
                pMem = (VOID *)((UINT32)pMem - uwGapSize);
            }
            //由于返回给用户的是用户可以使用的,还记得刚才说的跳过node吗,所以这里需要调整,找到node
            pstNode = (LOS_MEM_DYN_NODE *)((UINT32)pMem - OS_MEM_NODE_HEAD_SIZE);
            //检查node使用使用
            uwRet = osMemCheckUsedNode(pPool, pstNode);
            if (uwRet == LOS_OK)
            {
                osMemFreeNode(pstNode, pPool);
            }
        } while(0);
        return uwRet;
    }
    
    
    //释放函数
    
    static inline VOID osMemFreeNode(LOS_MEM_DYN_NODE *pstNode, VOID *pPool)
    {
        LOS_MEM_DYN_NODE *pstNextNode = (LOS_MEM_DYN_NODE *)NULL;
        LOS_DL_LIST *pstListHead = (LOS_DL_LIST *)NULL;
    
        OS_MEM_REDUCE_USED(OS_MEM_NODE_GET_SIZE(pstNode->uwSizeAndFlag));
        pstNode->uwSizeAndFlag = OS_MEM_NODE_GET_SIZE(pstNode->uwSizeAndFlag);
        //如果node的前一个节点不为空,且前一个节点没有使用,那么
        if ((pstNode->pstPreNode != NULL) &&
            (!OS_MEM_NODE_GET_USED_FLAG(pstNode->pstPreNode->uwSizeAndFlag)))
        {
            LOS_MEM_DYN_NODE *pstPreNode = pstNode->pstPreNode;
            //和前一个节点合并
            osMemMergeNode(pstNode);
            pstNextNode = OS_MEM_NEXT_NODE(pstPreNode);
            //后一个节点也没有使用,那么也和后一个节点合并,
            /*也就是说如果需要释放的节点位于两个都内有使用的节点之间那么前后都合并,防止内存碎片*/
            if (!OS_MEM_NODE_GET_USED_FLAG(pstNextNode->uwSizeAndFlag))
            {
                LOS_ListDelete(&(pstNextNode->stFreeNodeInfo));
                osMemMergeNode(pstNextNode);
            }
    
            LOS_ListDelete(&(pstPreNode->stFreeNodeInfo));
            pstListHead = OS_MEM_HEAD(pPool, pstPreNode->uwSizeAndFlag);
            if (NULL == pstListHead)
            {
                printf("%s %d\n", __FUNCTION__, __LINE__);
                return;
            }
    
            LOS_ListAdd(pstListHead,&(pstPreNode->stFreeNodeInfo));
        }
        else
        {
            pstNextNode = OS_MEM_NEXT_NODE(pstNode);
            //如果下一个节点没有使用,和下一个节点合并
            if (!OS_MEM_NODE_GET_USED_FLAG(pstNextNode->uwSizeAndFlag))
            {
                LOS_ListDelete(&(pstNextNode->stFreeNodeInfo));
                osMemMergeNode(pstNextNode);
            }
            //按照新节点的大小在list数组中找到合适的位置
            pstListHead = OS_MEM_HEAD(pPool, pstNode->uwSizeAndFlag);
            if (NULL == pstListHead)
            {
                printf("%s %d\n", __FUNCTION__, __LINE__);
                return;
            }
            将释放的内存和合并之后的生成的新节点插入合适的list
            LOS_ListAdd(pstListHead,&(pstNode->stFreeNodeInfo));
        }
    }
    

    这个函数就不详细分析了,不是很难,还有我也写累了。。。
    主要就是内存回收以及合并内存节点防止内存过于颗粒化出现大量碎片。

    liteos内存分配策略的优缺点

    liteos内存分配策略优点是简单,使用链表数组按照2的幂次方级数关系管理内存,缺点也很明显,容易出现内存碎片,举例如下:

    如果使用者每次都是分配–>释放—>分配—>释放,那么这样的方式是不会产生内存碎片的,但是如果按照分配—>分配—>释放—>释放。。。,这样不是交替的方式的话那么极容易产生内存碎片,即使没有使用的内存足够,但是如果没有使用的内存过于分散,那么用户分配还是会失败。

    liteos内存分配代码,在平时工作中帮助解决bug

    我们可以看到liteos的内存分配单吗相对简单,还是比较容易看懂的,所以我们自己的代码中也经常使用malloc等函数分配内存,有时候会忘记释放,或者其他的问题,引起系统出问题,这个时候,也许我们能使用liteos的LOS_MemAlloc替换掉我们的malloc这样很容易方便的定位为题。

    展开全文
  • 华为项目管理的精髓干货!可收藏

    万次阅读 2018-12-14 17:52:59
    华为一直非常重视项目管理,项目管理在促进公司发展、实现商业价值、推动人才培养等方面发挥了重要作用。记者就此专访了华为项目管理能力中心(PMCoE)部长易祖炜先生。 易祖炜介绍,华为的项目管理是一种业务运作...

    华为一直非常重视项目管理,项目管理在促进公司发展、实现商业价值、推动人才培养等方面发挥了重要作用。记者就此专访了华为项目管理能力中心(PMCoE)部长易祖炜先生。

    易祖炜介绍,华为的项目管理是一种业务运作模式。华为“以项目为中心”的运作不仅仅是一组实践或工具,更是一套相对完整的管理体系,包括政策、规则、流程、方法和IT工具平台、组织运作和评价等要素。这些要素在项目管理实践中集成应用,并通过一套三层的管控机制,有效开展项目、项目集和项目组合管理,实现商业价值。

    华为首先在营销和研发等体系引入项目管理,并经过多年实践推广至目前的变革、基建等领域。截至2018年,华为已拥有各类认证的各级别专职项目经理近5000人。

    一、强底气,建设项目管理体系

    二、用项目组合管理价值

    三、关注商业价值实现

    四、科学度量成熟度

    五、聚人气,培育项目管理文化

    华为项目管理文化包含如下三种文化:


    华为项目管理文化与华为企业文化一脉相承,是华为核心价值观的内涵在项目管理活动中的延伸和丰富,华为项目管理文化的精髓包括如下几方面:

    以客户为中心

    契约精神

    结果导向

    团队协同作战

    写在最后

    回顾20多年华为项目管理实践,易祖炜认为,华为的发展是和客户一道成长的结果,是华为不断自我否定、自我批判、凤凰涅槃的结果。目前,华为已成功入选为PMI全球高层理事会成员企业,与全球其他领域的大公司携手引领和推动项目管理的发展。

    在数字化时代, 项目管理也需要不断与时俱进。在实现华为“把数字世界带入每个人、每个家庭、每个组织,构建万物互联的智能世界”新愿景的过程中, 项目管理大有可为!

    展开全文
  • 看看人家华为的项目组成员表是怎么做的,跟你们公司的比较,有哪些优缺点
  • Atitit 华为管理者内训书系 以奋斗者为本 华为公司人力资源管理纲要 attilax读后感       序 言上篇:价值创造、评价与分配第一章 全力创造价值1.1 围绕价值创造展开人力资源管理1.1.1 什么是价值1.1.2 活下去是...
  • 这几天,华为推出了一款华为nova 7 SE乐活版,它搭载的是麒麟820E 5G芯片,这也是华为在无芯可用的情况下,又公布的一...有哪些优缺点华为nova7SE乐活版有哪些优缺点屏幕方面,华为nova7SE乐活版配备了一块6.5英寸LC...
  • app四种开发模式的优缺点

    千次阅读 2019-05-05 17:30:24
    APICloud由“云API”和“端API”两部分组成,可以帮助开发者快速实现移动应用的开发、测试、发布、管理和运营的全生命周期管理。每一个页面都带有自己的cookies,不经过登录入口直接访问页面,由于cookies不正确会...
  • 网页链接转app优缺点 优点:开发和发布都比较方便,开发成本也低,可以做到app一年及以上不更新,页面随时可以更新。 缺点:需要手机网站反应速度要快,用好的服务器,否则打开会慢 ios免签封装: 免签封装是苹果...
  • 当今人们离不开互联网,作为互联网的组成部分之一——网站,是大家每天都要面对的,而今天,我就要说说我的站长之路,文中介绍了一些服务器商(阿里云,腾讯云,河南郑州景安,西部数码,华为云等)的一些优缺点。...
  • 体验环境 体验方式:PC端 ...了解华为软件开发云的项目管理服务功能,分析其优缺点; 瀑布化开发到敏捷开发的转型分析,以及未来软件开发模式的发展方向; 产品简介 产品名称:华为软件开发云
  • 双活数据中心解决方案缺点 虽然双活容灾解决方案对于集中式管理的数据中心更大限度的保证了业务生产的在线性及有效的防御了灾难性事件恢复业务生产的能力。但是双活数据中心的容灾方案还是存在一定的不足之处,理想...
  • 如果您想在线提供信息或应用程序,则需要一个安全可靠且量身定制的托管基础。 无论它是一个业余爱好网站,还是博客论坛,抑或...可以参考这篇文档:【云服务器推荐】2021年腾讯云、阿里云、华为云服务器价格和配置评测
  • 今天就介绍一下,我用过这三个框架的看法以及他们之间的优缺点。 一、优点 1、uni-app 开发时参照uni-app官网会更便捷 uni-app是一套可以适用多端的开源框架,是一个使用 Vue.js 开发所有前端应用的框架,开发者...
  • 小团队?大团队?优缺点对比

    千次阅读 2020-06-05 11:45:00
    我们公司和大部分传统软件公司一样,随着业务的发展和新领域的开拓,公司的管理风格越来越像华为,这是不是最佳的演进路线,我觉得值得探讨,以下是我的思考,希望跟大家讨论。 一个问题 前段时间跟一个创业的朋友...
  • 腾讯云音视频SDK的调研报告之优缺点     缺点   优点               2015/05/20腾讯云正式对外开放QQ音视频,此项服务目前推出时间算是比较短,使用其SDK且有所名气的App目前市场上还几乎没有看到。...
  • 往期文章: 华为软件开发云测评报告一:项目管理 华为软件开发云测评报告二:代码检查 体验环境 体验方式:PC端 ...了解华为软件开发云的测试管理服务功能,分析其优缺点; 自动化测试工具
  • 这种数据集合具有如下特点:尽可能不重复,以最优方式为某个特定组织的多种应用服务,其数据结构独立于使用它的应用程序,对数据的增、删、改、查由统一软件进行管理和控制。 阿里云提供的云数据库RDS(ApsaraDB ...
  • 2017年8月华为杭研所招面试经验

    千次阅读 2017-08-26 21:44:32
    本人杭电的学生于8月26日参加了华为杭研所的招面试,本着感恩前人面试经验,造福后来人的想法写下此次面经。先申明,今天刚面完结果如何不知道,本人面试下来感觉挂的概率比较大。 伴着清晨的瓢泼大雨中醒来,望...
  • 本文就在我们学院碰到的一些共同误解的地方在此对比列出两种语言的优缺点。当然还有更多的争论在进行中但是本文汇中我们将选取最为普遍的来进行讨论。我们希望能够消除误解并且尽可能地为那些不能及时跟进R或SAS的...
  • 提供强大的部署、管理和监控工具。Cloudera开发并贡献了可实时处理大数据的Impala项目。 Hortonworks 不拥有任何私有(非开源)修改地使用了100%开源Apache Hadoop的唯一提供商。Hortonworks是第一家使用了Apache ...
  • 在现在的智能手机圈,主要有两类操纵系统,一类是谷歌的安卓系统,目前最新的版本为Android P系统,该系统为开源系统,简单讲就是业态共享,比如谷歌手机的原生系统、华为的EMUI定制系统、小米的MIUI定制系统、魅族...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,007
精华内容 2,002
关键字:

华为管理的优缺点