精华内容
下载资源
问答
  • 世界国际服1.12.2版本,游戏运行仅调用单核,一核跑满多核围观,求多核优化插件。愿付费。
  • J2ME优化压缩PNG文件 4个目标文件 内容索引:JAVA源码,综合应用,J2me游戏,PNG,图形处理 这是个J2ME控制台程序,它能剔除PNG文件中的非关键数据段,减少文件大小从而达到压缩图片的目的。而图片的质量并不会受到损失...
  • * 有强大的代码优化功能的TriCore C/C++ 多核编译器套餐 * Compiler for HSM security module * GTM/MCS assembler * EclipseTM集成开发环境 * 通过ISO26262安全认证   2. HighTec公司的开发编译...

    TC234/TC275 是英飞凌推出的较新一代AURIX 系列的单核/三核处理器,适合应用于车载控制器的开发,目前在很多车型上有在使用,下面对两种芯片做个简单的分析对比:

    1)TC275

    1. 该芯片有三个运算核、两个校验核,类似于将三个高性能单片机集成在一起,功能非常强大;
    2. 该芯片推出较早、各种开发例子、资料文档、开发工具相对较为齐全;其他型号均是在TC275之后推出,如性价比更高的TC234、TC212、TC297等等
    3. 由于集成3核、价格优势不是太明显;
    4. 有4通道can接口,4个can公用256个接收发送邮箱;
    5. 有电机控制器专用接口;
    6. 内部Flash有4Mbyte;

    2)TC234

    1. 该芯片有一个运算核、一个校验核,和普通的单片机基本上没什么区别。
    2. 所有的开发工具对于TC275相对较少,目前还没有相关的中文文档;
    3. TC234的价格不到TC275价格的40%,个人认为已经可以满足车载控制器的要求,是性价比较高的代表。
    4. 有6路can接口,这个是我比较喜欢的,前面3个can公用128个接收发送邮箱,后面3个can公用128个接收发送邮箱。这一点比TC275还有多两路can;
    5. 内部Flash有2Mbyte,184K的RAM;

     

    开发工具:

    1)软件编程开发环境:首选Tasking,功能强大;其次Hightec,适合个人使用;

    2)下载仿真工具:miniwiggler,劳特巴赫、PLS;

    3)工具价格功能介绍

    1. TC275要求的最低版本是Tasking 4.2.2,TC234要求的最低版本是4.3.3,选购的时候请注意,否则不能在线仿真;Tasking的试用版仅半个月,需要与MAC地址绑定,可是我一直没有申请到。较新的版本是Tasking6.2,该版本支持所有的芯片,同时内部还有PinMapper功能,可自动生成底层引脚配置程序,但是与电脑的CID吗绑定,不容易破解;
    2. Hightech的价格未知,但是试用期一年,基本上采用试用版既可以完成开发,需要在网上申请license,与MAC地址绑定,我使用的是4.9.1版本,不过已经有更新的版本发布了;
    3. Tasking的价格最低要6万RMB,和画PCB的 Altium Designer同一家公司,非英飞凌出品;
    4. 英飞凌出品:miniwiggler的官方价格约1000RMB,淘宝价格300RMB,自制成本价格低于100RMB;
    5. 劳特巴赫:功能强大,支持n多种芯片,价格从8万到30万RMB之间的各种套装,可怜本人只闻其声,未见其人,欢迎财大气粗的大侠交流下使用体验。

    4)工具组合介绍

    1. Tasking +miniwiggler:可以编写代码、生产目标文件,实现基本的调试功能,可设置断点、逐行调试、观察变量等等
    2. Hightec+miniwiggler:Hightec可以编写代码,但是无法在线调试,进支持Startkit开发板的在线调试。使用英飞凌的memtool上位机+miniwiggler将生成的文件下载到单片机里面运行;
    3. Hightec+pls:pls的hightec主推的配套组合,功能和当然非常强大;
    4. Tasking、hightec + 劳特巴赫:这个不用讲了,天下最强组合、没有解决不了的问题。

    5)根据性价比推荐组合

    1. Hightec (0RMB)+ 自制(300RMB): 可以在线仿真和调试,性价比最高,有需要的可以联系我

    2. Tasking + miniwiggler(北京乾勤300RMB或者英飞凌1000RMB):可以在线调试仿真
    3. 注意:Hightec (0RMB)+ miniwiggler(北京乾勤300RMB或者英飞凌1000RMB):无法在线调试,可以编译下载;
    4. 其他组合:有钱就是任性;

    附录:

    HighTec是英飞凌工具合作伙伴。

    HighTec EDV Systeme 公司成立于1982年, 是世界上最大的基于开源的商业编译工具供应商。 HighTec GNU-based compiler 在工业应用领域有超过30年的经验,在汽车领域有超过20年的应用经验,客户遍及世界一流的行业公司。由于和一些主要汽车OEMs和半导体供应商有紧密的合作,在GNU-based compiler 和debugger 中融入了支持不同32位核的特别功能和不同的代码优化方法。该产品包括以下基本内容:

    * a GNU-based C/C++ compiler 工具链

    * 基于Eclipse的集成开发环境

    HighTec EDV Systeme 公司在布拉格设立有能力和服务中心,负责嵌入式多核应用开发和功能安全的咨询和工程服务。

    HighTec公司总部在德国Saarbrücken,北京西能电子科技发展有限公司是国内的代理商,负责HighTec 编译工具在国内的市场推广和技术支持。

     

    1. HighTec公司GNU C/C++ Compiler开发编译工具平台

    德国HighTec公司GNU C/C++ Compiler开发编译工具平台,可以支持infineon Tricore系列产品的嵌入式开发。HighTec公司的开发编译工具平台包括:

    * 有强大的代码优化功能的TriCore C/C++ 多核编译器套餐

    * Compiler for HSM security module

    * GTM/MCS assembler

    * EclipseTM集成开发环境

    * 通过ISO26262安全认证

     

    2. HighTec公司的开发编译工具平台主要特点

    开发编译工具包含有强大的操作引导模板wizards,并支持最新的多核结构,它很好的完成项目管理、从 compiler, assembler 到linker 的整个build process ,以及实现对硬件的初始化。主要功能特点包括:

    * 强大的项目管理

    * 操作模板引导功能

    * 版本控制

    * DAvE 工程文件导入功能

    * 基于模型驱动的图形化内存分配功能:Eclipse?中基于模型化GUI功能进行内存分配,使代码和数据放置在内存中的合适区域。

    其工作流程为:首先选择MCU型号;然后产生工程项目,包括正确的启动代码,必要的硬件初始化,内存分配,头文件描述等

     

    2.1  C/C++ compiler 套餐的特点:

    * 产生稳定、紧凑和快速可执行的代码

    * Compiler能快速build,能同时多次起动,可以并行编译,加快build过程

    * AUTOSAR MCAL driver support:在用到AUTOSAR操作系统时,compiler可以指定寄存器,以便用户特别使用,以免compiler占用或使用。同时支持不同AUTOSAR供应商:ETAS, Elektrobit 和Vector等。

    * ANSI/ISO conformance

    * Multi-core support (ISO and EABI compliant)

    * 为了充分发挥32位MCU核的强大功能,HighTec的compiler套餐采用了领先的代码优化技术,以及必要的对硬件的控制。代码优化策略有闭环优化、函数在线和全局优化两种方式,这样节省代码执行时间和提高代码密度。

    * 长期的产品支持和维护

    * Commercial standard and math libraries(no open source)

    * 多种寻址模式包括:absolute, register relative, circular:Tricore结构可以实现不同寻址模式,这样提高效率,一方面地址计算省略了,同时地址由汇编指令编码。compiler实现不同寻址模式是通过‘pragma’语句的源代码完成的,这样控制和分配代码和数据在合适的内存空间。

    * 代码覆盖率功能支持Code coverage support

    * SIMD and FPU support

    * PCP C-Compiler

    HighTec C/C++ compiler产生位置独立的代码PIC和位置独立的数据PID,这个功能在ECUs厂家生产和测试过程编程烧写中很重要,适合汽车软件的多平台运行要求。

     

    2.2  支持ISO-26262标准的应用开发

    在Tricore CPU结构核中,所有标注PRO-SILTM的产品都满足ISO 26262(ASIL-D)和IEC 61508(SIL-3)的要求。在infineon的SafeTcore安全套件中,程序启动阶段和正常运行阶段时,有一系列功能强大的自检程序,运行于PCP中,以确保用户的软件和CPU硬件在正常环境运行。HighTec PCP C-Compiler 支持SafeTcore安全套件。

    根据ISO-26262,汽车行业的应用程序供应商在随机的时间里可以复制应用程序以及软件的版本状态。HighTec 提供长期的服务,不管是固定的版本号,还是有升级的。

    在处理故障检测和防错方法上,HighTec 提供了先进的bug-finding-compiler,适合于已经知道的silicon bug和compiler bug。Compiler可以检测客户的应用代码,看是否被bug影响了,如果影响了,哪个模块受到影响。这样,用户只是重新rebuild受影响的模块,节约build和testing的时间。

    关于安全要求高的应用中,对代码覆盖率的分析功能,HighTec C/C++ compiler 支持产生instrumented code。应用程序运行时,采集到的代码覆盖信息写到标准的gcov format格式中,相应的源代码的代码覆盖率信息在Eclipse editor中显示。

    在软件的build process过程中,可追溯行是保证软件质量的保障。HighTec C/C++ compiler 通过记录compiler版本号和build可选信息,保证可追溯性。这些信息存储在可执行文件的特定区域,而且不会下载到目标板中,而占用额外的内存空间。

    除此之外,HighTec工具里还可以对变量指定’alias’名,这样和客户的命名规则一致。

     

    2.3  支持多核系统开发Multi-core support

    单核向多核系统转换:TriCore C/C++ 编译器套餐支持同类或不同类的多核结构。HighTec对多核的支持,不必在linker level对源代码进行匹配。这种ISO- and EABI-compliant多核支持功能使得从单核到多核源代码输出变得简单,容易实现可linker level执行代码和数据代码的指定。不同核之间的数据交换通过hide-and visibility机制处理,即指定核之间用户定义的接口。如果数据和代码要对所有核可视,则要直接指定。所有核共享的数据和代码,在一个单独的文件中输出,可以用来实现核之间的对比分析。hide-and visibility机制降低了分布式系统的复杂性,减少了系统调试的工作量,提高了软件系统的可维护行。

    另外,在数据和代码相互分开的情况下,在单独的核中执行独立的应用程序是没有问题的。

    资源的访问和映射:一个核可以进入它本地的资源,如通过本地地址空间进入RAM。另外,这些资源可以映射到全局地址空间,其他的核也可以访问。这样,内存可以以不同地址访问,如本地地址空间或全局地址空间,对不同的核结构也是可行的,如GTM/MCS模块。

    Linker 和输出文件:HighTec Tricore linker自动处理不同核的内存重新映射。Linker可以连接不同核的目标文件,产生一个输出elf文件,由全球主要的debugger 工具供应商 PLS, Lauterbach, Isystem等都支持多核调试。

    HighTec 工具支持不同的核架构,如GTM/MCS和HSM安全模块。Tricore, GTM和HSM的二进制可以连接输出到一个ELF文件中,并上载‘en bloc’到目标系统。

    高效的寻址模式,如small addressing mode,可以单独用于每个核中。每个核的对应地址寄存器需要在启动代码中初始化。Linker会自动对每个核的small addressable area必要的基本寄存器初始化

     

    展开全文
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    J2ME优化压缩PNG文件 4个目标文件 内容索引:JAVA源码,综合应用,J2me游戏,PNG,图形处理  这是个J2ME控制台程序,它能剔除PNG文件中的非关键数据段,减少文件大小从而达到压缩图片的目的。而图片的质量并不会受到损失...
  • 浏览器内核和性能优化总结 对于当下主流浏览器,很多人... 从网上找了很多资料,参考了很多文章,总结一下浏览器的内核,以及对其性能的优化。 文章参考:http://www.cnblogs.com/qq313462961/p/6114085.html http

    浏览器内核和性能优化总结


    对于当下主流浏览器,很多人并不清楚它们内核具体是什么,有何特点;有的人编写html和CSS代码时,乱写一通,殊不知错误的写法会消耗浏览器更多的性能,导致加载变慢。
    我从网上找了很多资料,参考了很多文章,总结一下浏览器的内核,以及对其性能的优化。

    文章参考:

    http://www.cnblogs.com/qq313462961/p/6114085.html
    http://www.cnblogs.com/ada-zheng/p/4308581.html

    浏览器内核

    定义

    浏览器内核负责对网页语法进行解释并渲染。 通常所说的浏览器内核也就是浏览器所采用的渲染引擎JS 引擎
    渲染引擎决定了浏览器如何显示网页的内容以及页面的格式信息。JS 引擎则是解析 Javascript 语言,执行 javascript 语言来实现网页的动态效果。
    不同的浏览器内核对网页编写语法的解释也有不同,因此同一网页在不同的内核的浏览器里的渲染效果也可能不同。

    四大引擎内核:Trident,Gecko,Presto,Webkit

    Trident内核

    代表产品IE浏览器,又称其为IE内核,Trident是微软开发的一种排版引擎。

    使用Trident渲染引擎的浏览器包括:IE、傲游、世界之窗浏览器、Avant、腾讯TT、Netscape 8、NetCaptor、Sleipnir、GOSURF、GreenBrowser和KKman等。

    Gecko内核

    代表作品Mozilla Firefox,Gecko是一套开放源代码的、以C++编写的网页排版引擎。

    Gecko是最流行的排版引擎之一,仅次于Trident。使用Gecko渲染引擎的浏览器包括:Firefox、Netscape6至9。

    Presto内核

    代表作品OperaPresto,是由Opera Software开发的浏览器排版引擎,供Opera 7.0及以上使用。它取代了旧版Opera 4至6版本使用的Elektra排版引擎,该款引擎的特点就是渲染速度的优化达到了极致,然而代价是牺牲了网页的兼容性

    Opera 在 2013 年 2 月宣布放弃 Presto,转用webkit引擎,Presto 内核的 Opera 浏览器版本永远的停留在了 12.17。在 Chrome 于 2013 年推出 Blink 引擎之后,Opera 也紧跟其脚步表示将转而使用 Blink 作为浏览器核心引擎

    WebKit内核

    代表作品SafariChrome ,主要用于Mac OS系统,它的特点在于源码结构清晰渲染速度极快。缺点是对网页代码的兼容性不高,导致一些编写不标准的网页无法正常显示。

    现在很多人错误地把 webkit 叫做 chrome内核,殊不知Webkit 的鼻祖其实是 Safari。

    主要代表作品有Safari和Google的浏览器Chrome。

    Chromium/Blink

    Chromium引擎虽然是属于WebKit的分支,却把WebKit的代码梳理得可读性提高很多,所以以前可能需要一天进行编译的代码,现在只要两个小时就能搞定。因此Chromium引擎和其它基于WebKit的引擎所渲染页面的效果也是有出入的。

    Chrome放弃Chromium引擎转而使用最新的Blink引擎(基于WebKit2——苹果公司于2010年推出的新的WebKit引擎),Blink对比上一代的引擎精简了代码、改善了DOM框架,也提升了安全性。

    浏览器渲染原理

    Web页面运行在各种各样的浏览器当中,浏览器载入、渲染页面的速度直接影响着用户体验简单地说,页面渲染就是浏览器将html代码根据CSS定义的规则显示在浏览器窗口中的这个过程。先来大致了解一下浏览器都是怎么干活的:
      1. 用户输入网址(假设是个html页面,并且是第一次访问),浏览器向服务器发出请求,服务器返回html文件;
      2. 浏览器开始载入html代码,发现标签内有一个标签引用外部CSS文件;
      3. 浏览器又发出CSS文件的请求,服务器返回这个CSS文件;
      4. 浏览器继续载入html中部分的代码,并且CSS文件已经拿到手了,可以开始渲染页面了;
      5. 浏览器在代码中发现一个标签引用了一张图片,向服务器发出请求。此时浏览器不会等到图片下载完,而是继续渲染后面的代码;
      6. 服务器返回图片文件,由于图片占用了一定面积,影响了后面段落的排布,因此浏览器需要回过头来重新渲染这部分代码;
      7. 浏览器发现了一个包含一行Javascript代码的< script >标签,赶快运行它;
      8. Javascript脚本执行了这条语句,它命令浏览器隐藏掉代码中的某个(style.display=”none”)。杯具啊,突然就少了这么一个元素,浏览器不得不重新渲染这部分代码;
      9. 终于等到了的到来,浏览器泪流满面……
      10. 等等,还没完,用户点了一下界面中的“换肤”按钮,Javascript让浏览器换了一下标签的CSS路径;
      11. 浏览器召集了在座的各位,“大伙儿收拾收拾行李,咱得重新来过……”,浏览器向服务器请求了新的CSS文件,重新渲染页面。

     
    说到页面为什么会慢?那是因为浏览器要花时间、花精力去渲染,尤其是当它发现某个部分发生了点变化影响了布局,需要倒回去重新渲染,内行称这个回退的过程叫reflow

    reflow几乎是无法避免的。现在界面上流行的一些效果,比如树状目录的折叠、展开(实质上是元素的显示与隐藏)等,都将引起浏览器的 reflow。鼠标滑过、点击……只要这些行为引起了页面上某些元素的占位面积、定位方式、边距等属性的变化,都会引起它内部、周围甚至整个页面的重新渲染。

    reflow问题是可以优化的,我们可以尽量减少不必要的reflow。比如开头的例子中的图片载入问题,这其实就是一个可以避免的reflow——给图片设置宽度和高度就可以了。这样浏览器就知道了图片的占位面积,在载入图片前就预留好了位置。

    另外,有个和reflow看上去差不多的术语:repaint,中文叫重绘。 如果只是改变某个元素的背景色、文字颜色、边框颜色等等不影响它周围或内部布局的属性,将只会引起浏览器repaint。repaint的速度明显快于 reflow(在IE下reflow要比repaint 更缓慢)。

    从浏览器的渲染原理分析CSS性能

    加载页面时浏览器的具体工作流程:

    1、解析HTML以重建DOM树:渲染引擎开始解析HTML文档,转换树中的标签到DOM节点,它被称为“内容树”。

    2、构建渲染树:解析CSS(包括外部CSS文件和样式元素),根据CSS选择器计算出节点的样式,创建另一个树 ——— 渲染树。

    3、布局渲染树: 从根节点递归调用,计算每一个元素的大小、位置等,给每个节点所应该出现在屏幕上的精确坐标。

    4、绘制渲染树(Painting the render tree) : 遍历渲染树,每个节点将使用UI后端层来绘制。

    主要的流程就是:构建一个dom树,页面要显示的各元素都会创建到这个dom树当中,每当一个新元素加入到这个dom树当中,浏览器便会通过css引擎查遍css样式表,找到符合该元素的样式规则应用到这个元素上。

    注意了:css引擎查找样式表,对每条规则都按从右到左的顺序去匹配。

    对此,在CSS书写过程中,总结出如下性能提升的方案:

    1.避免使用通配规则 : *{…} 计算次数惊人!非常影响性能。
    2.尽量少的去对标签进行选择,使用class 和 id属性.
    3.不要去用标签限定ID或者类选择符 如:ul#nav,应该简化为#nav
    4.尽量少的去使用后代选择器,降低选择器的权重值 后代选择器的开销是最高的,尽量将选择器的深度降到最低,最高不要超过三层,更多的使用类来关联每一个标签元素
    5.考虑继承 ,了解哪些属性是可以通过继承而来的,然后避免对这些属性重复指定规则

    总而言之,使用尽可能短的匹配规则去匹配元素

    总结

    选用高效的选择符,可以减少页面的渲染时间,从而有效的提升用户体验。也许当你想让渲染速度最高效时,你可能会给每个独立的标签配置一个ID,然后用这些ID写样式。那的确会超级快,也超级荒唐!这样的结果是语义极差,后期的维护也是难到了极点。

    但说到底,CSS性能这东西对于小的项目来讲可能真的是微乎其微的东西,提升可能也不是很明显,但对于大型的项目肯定是有帮助的。而且一个好的CSS书写习惯和方式能够帮助我们更加严谨的要求自己。

    展开全文
  • Java 技术书籍大全

    千次阅读 多人点赞 2019-08-11 20:38:49
    [《精通lambda表达式:Java多核编程 Mastering Lambdas: Java Programming in a Multicore]》 《Java 9模块化开发:核心原则与实践》 《Java JDK 9学习笔记》 [《Java 9编程参考官方大全(第10版) Java:...

    前言

    本文档目前已收录 277本 Java相关领域经典技术书籍,从初级开发者到资深架构师,涵盖 Java 从业者的各个阶段。

    涵盖领域:Java入门书籍,Java基础及进阶书籍,框架与中间件,架构设计,设计模式,数学与算法,JVM周边语言,项目管理&领导力&流程,职业素养与个人成长,格局与视野,面试参考书等。

    入门书籍

    基础书籍

    多线程与并发

    网络编程

    数据结构

    语言基础

    进阶

    性能优化

    响应式编程

    JVM虚拟机

    代码&设计优化

    设计模式

    框架与中间件

    数据库

    缓存与NoSQL

    消息队列

    ORM框架

    Spring家族

    高并发

    分布式

    搜索引擎

    大数据

    架构

    分布式架构

    微服务架构

    架构方法论

    JVM周边语言

    项目管理&领导力&流程

    项目管理

    团队管理

    数学与算法

    数学

    算法

    职业素养与个人成长

    职业素养提升

    个人软技能

    大厂出品

    阿里巴巴技术丛书

    京东技术丛书

    工具书

    面试求职

    格局与视野

    Java之外

    网络知识

    安全知识

    工具

    运维&DevOps

    展开全文
  • Linux内核争抢式并发在SMP多核扩展上的不足

    千次阅读 多人点赞 2019-08-23 00:04:42
    本文来自:《被神话的Linux, 一文带你看清Linux在多核可扩展性设计上的不足》 我们先来看一段来自猛士王垠的话: 跟有些人聊操作系统是件闹心的事,因为往往会抛弃一些术语和概念,从零开始讨论。试图从“计算...

    本文来自:《被神话的Linux, 一文带你看清Linux在多核可扩展性设计上的不足

    我们先来看一段来自猛士王垠的话:

    跟有些人聊操作系统是件闹心的事,因为我往往会抛弃一些术语和概念,从零开始讨论。我试图从“计算本质”的出发点来理解这类事物,理解它们的起因,发展,现状和可能的改进。我所关心的往往是“这个事物应该是什么样子”,“它还可以是什么(也许更好的)样子”,而不只是“它现在是什么样子”。不明白我的这一特性,又自恃懂点东西的人,往往会误以为我连基本的术语都不明白。于是天就这样被他们聊死了。

    摘自《关于微内核的对话

    不评价王垠其人,但是以理解这段话为前提,方能理解正文的内容。

    在正文开始之前,我先来评论一下网友对本文的评论。由于此文为发表之后的转载,所以按照正常的顺序,可以先看“正文”部分,然后再回过头来看 “评论的评论”。

    评论的评论

    本文发表之后,争议甚多,我也一一看了,其中比较多的不乏四类:

    1. 赞,牛逼,好,大神。
    2. 真正的问题讨论。
    3. 用细节较真儿我从来没有说过的话。
    4. 扫一眼大概就来谩骂。

    其中第1点没有意义,所以这里不评。从第2点开始。

    当有人读懂我文中的 并发争抢和仲裁调度之间的对立 后,提出了类比市场经济和计划经济的比较,引发了进一步的思考。除了这个类比之外,还有一个评论我觉得不错:

    第一张图,左边是司法独立各自举证,右边是希特勒邪恶轴心凌驾一切法律,一切都由希特勒决定!希特勒说这叫高效!如果这个队列里面牺牲的是你呢?你还会认同希特勒邪恶轴心吗?你是时候学习一下什么叫自由、公平、文明了!

    同样的争论发生在网络领域。到底是我们目前的逐跳路由分布式控制的TCP/IP好呢,还是集中控制的SDN好呢?

    此外,还有这个:

    印象中,真正的众核编程一般是在数据平面绑定线程与核的映射,禁止操作系统调度的。

    确实如此,这就是我正文中提到的,真正的并行需要程序员自己去做,换句话说,这就是数据平面的事,类似DPDK的做法,而内核只负责控制平面,协调共享资源的访问。

    还有一个观点也是计算机科学的核心,那就是 trade off

    使用ipc还是自旋锁这取决于应用场景。context switch成本一般至少有几万个cpu周期,在高性能的场景这个数字是非常高的,这其中包括tlb flush,cache invalidation等。linux中大部分使用自旋锁的场景运行成本远小于几万个cpu周期。相比于ipc,使用自旋锁避免了context switch,开发也更简洁。 系统开发是trade off,不是哪个最牛逼用哪个,而是根据应用场景,选择最合适的技术,做均衡。

    这个不多说,这一行做久了都能悟出来。

    关于第3点,我引一个评论:

    写了半天,就说了一个多线程编程的常识,不要长时间持有锁。解决这个问题的方式,就是把耗时任务送到另外的线程去做,对应的设计模式叫主动对象(actor)。这个如此成熟的设计模式,内核里面也是有用的。我不搞内核,就搞应用开发…

    嗯,这是典型的 又自恃懂点东西的人,往往会误以为我连基本的术语都不明白

    此外,还有说spinlock可以被优化的。

    既然你说spinlock可以这样那样优化,IPC为什么就不能被优化,为什么IPC永远都摘不掉低效的帽子。再说了,我并没有说仲裁调度就一定要用IPC。只要是写到IPC这三个字母,我都小心翼翼地加上了假设,假设IPC已经被优化了,然而还是失败了。

    关于第4点,说我连个maintainer都不是,在这里瞎吹牛。呵呵了,我写的东西只是我的思考,我记得之前说过,我并不喜欢社区的氛围,也无意在这个领域去争个什么头衔或什么功名,我生命的意义在于生活和思考。

    另外,说Linux内核的spinlock已经被优化的不错的,这点我可以保证你错了,Linux内核的spinlock真的很糟糕,Linux内核里的spinlock说白了就是个错误,早就过时了。不理解这一点,就好比18世纪初的贵族拼命守着自家的豪华马车,打心眼里持续鄙视丑陋,笨重,肮脏的蒸汽机车,内燃机车一样。

    在读正文之前,请务必记住, 不要站在Linux内核的立场去理解这里的内容,否则和Linux内核不一样的就都是错的。

    幸亏没有提及rust语言写的redox内核,不然肯定会有人说它烂的一比…还是那句话,只要Linux在,别的都是错的。有个朋友说的不错,毕竟Linux给了大家饭碗啊。


    正文

    本文接着《有关微内核OS史上最透彻一篇 - 写于华为鸿蒙发布一周之际》https://mp.weixin.qq.com/s/MLCR7qqGFWyyP0KcZqW3Kw 继续写下去。

    我其实并不想讨论微内核的概念,也并不擅长去阐述概念,这是百科全书的事,但无奈最近由于鸿蒙的发布导致这个话题过火,也就经不住诱惑,加上我又一直比较喜欢操作系统这个话题,就来个老生常谈吧。

    说起微内核,其性能往往因为IPC饱受诟病。然而除了这个显而易见的 “缺陷” ,其它方面貌似被关注的很少。因此我写点稍微不同的。

    微内核的性能 “缺陷” 我假设是高开销的IPC引起的(实际上也真是),那么,我接下来便继续假设这个IPC性能是可以优化的,并且它已经被优化(即便不做任何事,随着硬件技术的发展,所谓的历史缺点往往也将逐渐弱化…)。我不公道地回避了核心问题,这并不是很道德,但为了下面的行文顺利,我不得不这么做。

    很多人之所以并不看好微内核,很大程度上是因为它和Linux内核是如此不同,人们认为不同于Linux内核的操作系统内核都有这样那样的缺陷,这是因为Linux内核给我们洗了脑。

    Linux内核的设计固化了人们对操作系统内核的理解上的观念 ,以至于 Linux内核做什么都是对的,反Linux的大概率是错的。 Linux内核就一定正确吗?

    在我看来,Linux内核只是在恰当的时间出现的一个恰好能跑的内核,并且恰好它是开源的,让人们可以第一次内窥一个操作系统内核的全貌罢了,这并不意味着它就一定是正确的。相反,它很可能是错误的。
    20世纪90年代,Windows NT系统初始,但很难看到它的内在,《windows internal》风靡一时;UNIX陷入纠纷,GNU呼之却不出,此时Linux内核满足了人们一切的好奇心,于是先入为主,让人们觉的操作系统就应该是这个样子,并且在大多数人看来,这是它唯一的相貌。

    本文主要说 内核的可扩展性

    先泼一盆冷水,Linux内核在这方面做得并非已经炉火纯青。

    诚然,近十几年来Linux内核从2.6发展到5.3,一直在SMP多核扩展方面精益求精,但是说实话架构上并没有什么根本性的调整,要说比较大的调整,当属:

    • O ( 1 ) O(1) O(1)调度算法。
    • SMP处理器域负载均衡算法。
    • percpu数据结构。
    • 数据结构拆锁。

    都是一些细节,没有什么让人哇塞的东西,还有更细节的cache刷新的管理,这种第二天不用就忘记的东西,引多少人竞折腰。

    这不禁让人想起在交换式以太网出现之前,人们不断优化CSMA/CD算法的过程,同样没有让人哇塞,直到交换机的出现,让人眼前一亮,CSMA/CD随之几乎被完全废弃,因为它不是 正确 的东西。

    交换机之所以 正确 的核心在于 仲裁。


    当一个共享资源每次只能容纳一个实体占用访问时,我们称该资源为 “必须串行访问的共享资源” ,当有多个实体均意欲访问这种资源时,one by one是必然的,one by one的方案有两种:
    在这里插入图片描述
    哪个好?说说看。

    争抢必会产生冲突,冲突便耽误整体通过的时间,你会选哪个?

    现在,我们暂时忘掉诸如宏内核,微内核,进程隔离,进程切换,cache刷新,IPC等概念,这些概念对于我们理解事情的本质毫无帮助,相反,它们会阻碍我们建立新的认知。比如,无论你觉得微内核多么好,总有人跳出来说IPC是微内核的瓶颈,当你提出一个类似页表项交换等优化后,又会有人说进程切换刷cache,寄存器上下文save/restore的开销也不小,然后你可能知道点 带有进程PID键值的cache方案 ,吧啦吧啦,最后一个show me the code 让你无言以对,一来二去,还没有认识全貌,便已经陷入了细节。

    所以,把这些忘掉,来看一个观点:

    • 对待必须串行访问的共享资源,正确的做法是引入一个仲裁者排队调度访问者,而不是任由访问者们去并发争锁!

    所谓 操作系统 这个概念,本来就是莫须有的,你可以随便叫它什么,早期它叫 监视器 ,现在我们姑且就叫它操作系统吧,但这并不意味着这个概念有多么神奇。

    操作系统本就是用来协调多个进程(这也是个抽象后的概念,你叫它任务也可以,无所谓)对底层共享资源的 多对一访问 的,最典型的资源恐怕就是CPU资源了,而几乎所有人都知道,CPU资源是需要调度使用的,于是任务调度一直都是一个热门话题。

    你看, CPU就不是所有任务并发争抢使用的,而是调度器让谁用谁才能用 。调度,或者说仲裁,这是操作系统的精髓。

    那么对于系统中共享的文件,socket,对于各种表比如路由表等资源,凭什么要用并发争抢的方式去使用?!所有的共享资源,都应该是被调度使用的,就像CPU资源一样。

    如果我们循着操作系统理应实现的最本质的功能去思考,而不是以Linux作为先入为主的标准去思考,会发现Linux内核处理并发明显是一种错误的方式!

    Linux内核大量使用了自旋锁,这明显是从单核向SMP进化时最最最简单的方案,即 只要保证不出问题的方案!

    也确实如此,单核上的自旋锁并不能如其字面表达的那样 自旋 , 在单核场景下,Linux的自旋锁实现仅仅是 禁用了抢占 。因为,这样即可保证 不出问题

    但到了必须要支持SMP的时候,简单的禁用抢占已经无法保证不出问题,所以 待在原地自旋等待持锁者离开 便成了最显而易见的方案。自旋锁就这样一直用到了现在。一直到今天,自旋锁在不断被优化,然而无论怎么优化,它始终都是一个不合时宜的自旋锁。

    可见,Linux内核一开始就不是为SMP设计的,因此其并发模式是错误的,至少不是合适的。


    有破就要有立,我下面将用一套用户态的代码来模拟 无仲裁的宏内核 以及 有仲裁的微内核 分别是如何对待共享资源访问的。代码比较简单,所以我就没加入太多的注释。

    以下的代码模拟宏内核中访问共享资源时的自旋锁并发争抢模式:

    #include <pthread.h>
    #include <signal.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <sys/time.h>
    
    static int count = 0;
    static int curr = 0;
    
    static pthread_spinlock_t spin;
    
    long long end, start;
    int timer_start = 0;
    int timer = 0;
    
    long long gettime()
    {
    	struct timeb t;
    	ftime(&t);
    	return 1000 * t.time + t.millitm;
    }
    
    void print_result()
    {
    	printf("%d\n", curr);
    	exit(0);
    }
    
    struct node {
    	struct node *next;
    	void *data;
    };
    
    void do_task()
    {
    	int i = 0, j = 2, k = 0;
    
    	// 为了更加公平的对比,既然模拟微内核的代码使用了内存分配,这里也fake一个。
    	struct node *tsk = (struct node*) malloc(sizeof(struct node));
    
    	pthread_spin_lock(&spin); // 锁定整个访问计算区间
    	if (timer && timer_start == 0) { 
    		struct itimerval tick = {0};
    		timer_start = 1;
    		signal(SIGALRM, print_result);
    		tick.it_value.tv_sec = 10;
    		tick.it_value.tv_usec = 0;
    		setitimer(ITIMER_REAL, &tick, NULL);
    	}
    	if (!timer && curr == count) {
    		end = gettime();
    		printf("%lld\n", end - start);
    		exit(0);
    	}
    	curr ++;
    	for (i = 0; i < 0xff; i++) { // 做一些稍微耗时的计算,模拟类似socket操作。强度可以调整,比如0xff->0xffff,CPU比较猛比较多的机器上做测试,将其调强些,否则队列开销会淹没模拟任务的开销。
    		k += i/j;
    	}
    	pthread_spin_unlock(&spin);
    	free(tsk);
    }
    
    void* func(void *arg)
    {
    	while (1) {
    		do_task();
    	}
    }
    
    int main(int argc, char **argv)
    {
    	int err, i;
    	int tcnt;
    	pthread_t tid;
    
    	count = atoi(argv[1]);
    	tcnt = atoi(argv[2]);
    	if (argc == 4) {
    		timer = 1;
    	}
    
    	pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
    	start = gettime();
    	// 创建工作线程
    	for (i = 0; i < tcnt; i++) {
    		err = pthread_create(&tid, NULL, func, NULL);
    		if (err != 0) {
    			exit(1);
    		}
    	}
    
    	sleep(3600);
    
    	return 0;
    }
    

    相对的,微内核采用将请求通过IPC(下面的代码只是模拟,并非真正发起IPC,而且,本文最开始有假设,所有讨论以IPC已经被优化为前提!)发送到专门的服务进程,模拟代码如下:

    #include <pthread.h>
    #include <signal.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <sys/time.h>
    
    static int count = 0;
    static int curr = 0;
    
    long long end, start;
    int timer = 0;
    int timer_start = 0;
    static int total = 0;
    
    long long gettime()
    {
    	struct timeb t;
    	ftime(&t);
    	return 1000 * t.time + t.millitm;
    }
    
    struct node {
    	struct node *next;
    	void *data;
    };
    
    void print_result()
    {
    	printf("%d\n", total);
    	exit(0);
    }
    
    struct node *head = NULL;
    struct node *current = NULL;
    
    void insert(struct node *node)
    {
    	node->data = NULL;
    	node->next = head;
    	head = node;
    }
    
    struct node* delete()
    {
    	struct node *tempLink = head;
    
    	head = head->next;
    
    	return tempLink;
    }
    
    int empty()
    {
    	return head == NULL;
    }
    
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
    static pthread_spinlock_t spin;
    
    int add_task()
    {
    	struct node *tsk = (struct node*) malloc(sizeof(struct node));
    
    	pthread_spin_lock(&spin);
    	if (timer || curr < count) {
    		curr ++;
    		insert(tsk);
    	}
    	pthread_spin_unlock(&spin);
    
    	return curr;
    }
    
    // 强度可以调整,比如0xff->0xffff,CPU比较猛比较多的机器上做测试,将其调强些,否则队列开销会淹没模拟任务的开销。
    void do_task()
    { 
    	int i = 0, j = 2, k = 0;
    	for (i = 0; i < 0xff; i++) {
    		k += i/j;
    	}
    }
    
    void* func(void *arg)
    {
    	int ret;
    
    	while (1) {
    		ret = add_task();
    		if (!timer && ret == count) {
    			break;
    		}
    	}
    }
    
    
    void* server_func(void *arg)
    {
    	while (timer || total != count) {
    		struct node *tsk;
    		pthread_spin_lock(&spin);
    		if (empty()) {
    			pthread_spin_unlock(&spin);
    			continue;
    		}
    		if (timer && timer_start == 0) {
    			struct itimerval tick = {0};
    			timer_start = 1;
    			signal(SIGALRM, print_result);
    			tick.it_value.tv_sec = 10;
    			tick.it_value.tv_usec = 0;
    			setitimer(ITIMER_REAL, &tick, NULL);
    		}
    		tsk = delete();
    		pthread_spin_unlock(&spin);
    		do_task();
    		free(tsk);
    		total++;
    	}
    	end = gettime();
    	printf("%lld   %d\n", end - start, total);
    	exit(0);
    }
    
    int main(int argc, char **argv)
    {
    	int err, i;
    	int tcnt;
    	pthread_t tid, stid;
    
    	count = atoi(argv[1]);
    	tcnt = atoi(argv[2]);
    	if (argc == 4) {
    		timer = 1;
    	}
    
    	pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
    	// 创建服务线程
    	err = pthread_create(&stid, NULL, server_func, NULL);
    	if (err != 0) {
    		exit(1);
    	}
    	start = gettime();
    	// 创建工作线程
    	for (i = 0; i < tcnt; i++) {
    		err = pthread_create(&tid, NULL, func, NULL);
    		if (err != 0) {
    			exit(1);
    		}
    	}
    
    	sleep(3600);
    
    	return 0;
    }
    

    我们对比一下执行同样多的任务,在不同的线程数的约束下,两种模式的时间开销对比图:
    在这里插入图片描述

    我们看到,在模拟微内核的代码中,用多线程执行并行访问共享数据curr时,开销不会随着线程数量的变化而变化,而模拟宏内核的代码中,总时间随着线程数的增加而线性增加,显然,这部分开销是自旋锁的开销。当今流行的CPU cache结构已经排队自旋锁的开销符合这种线性增长。

    那么为什么微内核的模拟代码中的锁开销没有随着线程数量的增加而增加呢?

    因为在类似宏内核的同步任务中,由于并发上下文的相互隔离,整个任务必须被一个锁保护,比如 Linux内核的tcp_v4_rcv 里面的:

        bh_lock_sock_nested(sk);
        // 这部分耗时时间不确定,因此CPU空转率不确定,低效,浪费!
        ret = 0;
        if (!sock_owned_by_user(sk)) {
            if (!tcp_prequeue(sk, skb))
                ret = tcp_v4_do_rcv(sk, skb);
        } else if (unlikely(sk_add_backlog(sk, skb,
                           sk->sk_rcvbuf + sk->sk_sndbuf))) {
            bh_unlock_sock(sk);
            NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
            goto discard_and_relse;
        }
        bh_unlock_sock(sk);
    

    然而,在微内核的代码中,类似上面的任务被打包统一交给单独的服务线程去 调度执行 了,大大减少了锁区里的延时。

    宏内核的隔离上下文并发抢锁场景需要锁整个任务,造成抢锁开销巨大,而微内核只要锁任务队列的入队出队操作即可,这部分开销和具体任务无关,完全可预期的开销。

    接下来让我们对比一下执行同样的任务,在不同CPU数量的约束下,两种模式的时间开销对比图:
    在这里插入图片描述

    可见,随着CPU数量的增加,模拟宏内核的代码锁开销大致在线性增加,而模拟微内核的代码,锁开销虽然也有所增加,但显然并不明显。

    为什么会这样?请看下面宏内核和微内核的对比图,先看宏内核:
    在这里插入图片描述
    再看微内核:
    在这里插入图片描述

    这显然是一种更加 现代 的方式,不光是减小了锁的开销提高了性能,更重要的是大大减少了CPU的空转,提高了CPU的利用率。

    我们先看一下模拟宏内核的代码在执行10秒时的CPU利用率:
    在这里插入图片描述
    观察下热点,可以猜测就是spinlock:
    在这里插入图片描述
    显然,CPU利用率那么高,并非真的在执行有用的task,而是在spin空转。

    我们再看下模拟微内核的代码在同样情况下的表现:
    在这里插入图片描述
    看下热点:
    在这里插入图片描述
    显然,仍然有个spinlock的热点,但显然降低了很多。在更高执行效率的保证下,CPU并没有那么高,剩余的空闲时间可以再去执行更多有意义的工作进程。

    本文只是展示一个定性的效果,实际中,微内核服务进程的任务队列的管理效率会更高。甚至可以硬件实现。【参见交换机背板的交换网络实现。】


    说了这么多,也许有人会说, NO,你这两个比对的case不严谨,你只模拟了访问共享的数据,如果是真的可并行执行的代码用微内核的方案岂不是要降低性能吗?平白自废武功,将并行改成串行!
    确实如此,但是 内核本身就是共享的。 操作系统本身就是协调用户进程对底层共享资源访问的。

    所以真并行需要程序员自己来 设计可并行的应用程序。

    内核本身就是共享的。 共享资源的多线程访问就应该严格串行化,并发争锁是一种最无序的方式,而最有效的方式则是统一仲裁调度。

    在我们日常生活中,我们显然能看到和理解为什么排队上车比拥挤着上车更加高效。在计算机系统领域,同样的事情我们也见于交换式以太网和PCIe,相比CSMA/CD的共享式以太网,交换机就是一个仲裁调度器,PCIe的消息hub也是扮演着同样的角色。


    其实,即便是宏内核,在访问共享资源时,也并不是全都是并发争锁的方式,对于敏感度比较高的资源,比如时延要求很高的硬件资源,系统底层也是仲裁调度实现的,比如网卡上层发包的队列调度程序,此外对于磁盘IO也有对应的磁盘调度程序。

    然而对于宏内核,更加上层的逻辑资源,比如VFS文件对象,socket对象,各种队列等等却没有采用仲裁调度的方式去访问,当它们由多个线程并发访问时,采用了令人遗憾的并发争锁模式,这也是不得已而为之,因为没有哪个实体可以完成仲裁,毕竟访问它们的上下文是隔离的。

    来个插叙。
    当进行Linux系统调优时,瞄准这些方面相关的热点基本就够了。大量热点问题都是这种引起的,open/close同一个文件,进程上下文和软中断同时操作同一个socket,收包时多个CPU上的软中断上下文将包排入同一个队列,诸如此类。

    如果你不准备去调优Linux,或许你已经知道Linux内核在SMP环境下的根本缺陷,调它作甚。多看看外面的世界,搞不好比你眼前唯一的那个要好。


    当我们评价传统UNIX以及Linux这种操作系统内核时,应该更多的去看它们缺失了什么,而不是一味的觉得它们就是对的。【你认为它是的,可能仅仅因为它是你第一个见到并且唯一见过的】


    如果非要说下概念,那就有必要说说 现代操作系统 的虚拟机抽象。

    对于我们经常说的 现代操作系统 而言,按照最初的冯诺伊曼结构,只有 CPU和内存多处理(包括所有的多进程,多线程等机制) 机制中被抽象了出来,而对于文件系统,网络协议栈等等却没有进行多处理抽象。换句话说,现代操作系统为进程提供了 独占的虚拟机抽象 ,该虚拟机仅仅包括CPU和内存:

    • 时间片调度让进程认为自己独占了CPU。
    • 虚拟内存让进程认为自己独享了内存。
    • 再无其它虚拟机抽象。

    在进程使用这些抽象资源时,现代操作系统无疑采用了仲裁调度机制:

    • 操作系统提供任务调度器仲裁CPU的分时复用(典型的是多级反馈优先级队列算法),为进程/线程统一分配物理CPU的时间片资源。
    • 操作系统提供内存分配算法仲裁物理内存空间的分配(典型的是伙伴系统算法),为进程/线程统一分配物理内存映射给虚拟内存。

    显然,正如本文开头说过的,操作系统并未任由进程们去并发争抢CPU和内存资源,然而对于其它几乎所有资源,操作系统并未做任何严格的规定。操作系统以两种态度对待它们:

    1. 认为其它资源并非操作系统核心的一部分,于是微内核,用户态驱动等等就形成了概念。
    2. 认为其它底层的资源也是操作系统核心的一部分,这就是宏内核比如Linux的态度。

    态度如何,这并不重要,宏内核,微内核,用户态,内核态,这些也只是概念而已,没有什么大不了的。关键的问题乃是:

    • 如何协调共享资源的分配。
      或空间资源,或时间资源的或并发争锁,或仲裁调度的方式分配。

    无疑,最大的争议就在CPU/内存之外如何协调非进程虚拟化的文件系统的访问和网络协议栈的访问。但无论它们俩的哪一个,目前无论是宏内核还是微内核都有非常非常棒的方案。 遗憾的是,这些很棒的方案都不是Linux内核所采用的方案。

    哦,对了Nginx便采取了类似微内核,交换机,PCIe的方法,Apache却不是。还有很多别的例子,不再一一赘述,只是想说一点,操作系统领域,核心的东西都是大象无形的,而不是那些形形色色的概念。

    摘录一段王垠聊微内核时的一段话:

    跟有些人聊操作系统是件闹心的事,因为我往往会抛弃一些术语和概念,从零开始讨论。我试图从“计算本质”的出发点来理解这类事物,理解它们的起因,发展,现状和可能的改进。我所关心的往往是“这个事物应该是什么样子”,“它还可以是什么(也许更好的)样子”,而不只是“它现在是什么样子”。不明白我的这一特性,又自恃懂点东西的人,往往会误以为我连基本的术语都不明白。于是天就这样被他们聊死了。

    这其实也是我想说的。

    so,忘掉微内核,宏内核,忘掉内核态,用户态,忘掉实模式,保护模式,这样你会更深刻地理解如何仲裁共享资源的访问的本质。


    关于自旋锁的话题,后面还会有文章专门阐释。


    【皮鞋?是干垃圾还是湿垃圾??真皮的皮鞋是湿垃圾,人造革的是干垃圾吗??】
    浙江温州皮鞋湿,下雨进水不会胖。

    展开全文
  • Flash

    千次阅读 2013-06-01 14:22:20
    使用Flash创作出的影片有自己的特殊档案格式(SWF),该公司声称全世界97%的网络浏览器都内建Flash播放器(FlashPlayer)。  3.Flash是Macromedia提出的“富因特网应用”(RIA)概念的实现平台之一。 编辑本段...
  • Unity大场景数据加载及优化方案

    万次阅读 多人点赞 2018-08-07 16:29:55
    前段时间,有几个虚拟仿真公司跟请教关于大地形的加载优化问题,它们使用的引擎都是自己研发的,引擎对于开发者来说,大同小异,它们的基本构造是一样的,关键是在于解决问题的方法,正是基于这个前提写了这个课程...
  • 配置文件2.sql优化(建立索引) 将mysql的当前环境变量输出到文件output.txt D:webmysql>mysql.exe --help > output.txt 查看tmp_table_size等配置项(临时表内存) 修改my.ini重启 在服务器上执行mysql ...
  • HoloLens开发与性能优化实践

    千次阅读 2017-08-21 13:29:10
    个人的实践经验来看,整个场景中,总渲染面数应当控制在 10-20 万以内。     图 6 面数较低的模型效果  2) 着色器 Shader Shader 对于图形渲染是至关重要的组件,在 HoloLens 上也是我们...
  • 互联网中常见优化手段

    千次阅读 2020-11-06 22:08:15
    性能优化对一个产品的重要性不言而喻,它直接影响网站的用户留存率,APP在商店的评分和用户粘性。一个响应慢的应用,即便它功能再强大,也留不住用户。 性能优化对一个程序员同样非常重要——如果你是一个有追求的...
  •  现在这个社会发展的太快,到处都充斥着各种各样的资源,各种开源的平台,如github,codeproject,pudn等等...很多初创业的老板可能都曾经说过基本上的程序员不需要自己写算法,但是他们要学会搜索,强有力的搜索能
  • 题: 优秀的硬件 需要 优秀的软件 来支持发信站: 瀚海星云 (2007年04月14日23:36:25 星期六), 站内信件 WWWPOST题记:看到有业内人士介绍多核处理器,有人质疑多核处理器的性能提升,那就来介绍一下多核处理器要在...
  •  大家对并发(concurrency)、多线程(Multi-Threading)程序设计肯定不陌生,因为在当今多核CPU时代到处可见,从底层的操作系统(OS)到上层的应用程序,从服务端到客户端,从低级语言到高级程序语...
  • Linux转发性能评估与优化(转发瓶颈分析与解决方案)

    万次阅读 多人点赞 2015-06-28 00:22:26
    虽然近年在路由器领域有人提出了输入队列管理,但是这项技术对于Linux而言就是另一个世界,而,把它引入了Linux世界。 2.网卡对数据包队列Buff管理 在Linux内核中,几乎对于所有数据结构,都是需要时alloc,完毕后...
  • perl性能提升:优化perl

    千次阅读 2008-02-22 18:12:00
    优化 Perl 榨取代码的最大性能
  • 性能优化,作为工程师界的“上乘武功”,是我们在开发中老生常谈的话题,也是一名开发者从入门向资深进阶的必经阶段,虽然我们看到过很多的标准、军规,但在真正实践中,却常常力不从心,不知道落下了什么,不知道...
  • 从最初的基准测试结果来看,偏向锁提供了最佳的性能,比其他的优化方式更有效。测试的结果似乎表明获取锁是一项昂贵的操作。但是在得出最终的结论之前,决定先对结果进行检验:的同事们在他们的机器上运行了...
  • 现在的主流CPU都是多核的,有的运用了多线程技术(Hyper-threading,简称HT)。多核可能还容易理解些,相信不少玩家都能说出个所以然。但超线程是个什么东西,究竟有什么实际意义,一个支持超线程的CPU开启和关闭HT...
  • “老子”是伟大的多核计算科学家

    千次阅读 2013-01-19 20:02:08
    道家的思想可谓博大精深,“老子”的《道德经》成为翻译为外国文字最多的中国书籍,同时也是世界上翻译成外国文字第二多的书籍,仅次于圣经。要知道,《圣经》子所以成为翻译成外国文字第一多的书籍,是因为有10多亿...
  • 其实并不想讨论微内核的概念,也并不擅长去阐述概念,这是百科全书的事,但无奈最近由于鸿蒙的发布导致这个话题过火,也就经不住诱惑,加上又一直比较喜欢操作系统这个话题,就来个老生常谈吧。 说起微内核,其...
  • 游戏性能与多核CPU的疑问 第一个问题,近几年为什么游戏主旋律都在GPU的选择上,而往往都是CPU能力过剩,难道CPU就没有压榨的空间? 先拿吃鸡游戏举例,引用一张评测文章里的CPU与显卡不同组合配置的大逃杀benchmark...
  • 下面是转载的自己的原文。线速问题很多人对这个线速概念存在误解。认为所谓线速能力就是路由器/交换机就像一根网线一样。而这,是不可能的。应该考虑到的一个概念就是延迟。数据包进入路由器或者交换机,存在一...
  • 作者 | Yan Gu来源 | 转载自知乎用户Yan Gu【导读】随着计算机技术的发展,毫无疑问现代计算机的处理速度和计算能力也越来越强。...随着 Intel 的 NetBurst 架构退出江湖,处理器彻底进入了多核时代,从最初的...
  • 扩展的不同方面 大O符号 1使用StringBuilder 小结 2避免使用正则表达式 小结 3不要使用iterator方法 ...9优化自定义hasCode方法和equals方法 10考虑使用set而并非单个元素 总结 什么是全网域?或者说如何确保全网域
  • web性能优化指南

    千次阅读 2015-01-24 17:45:06
    关于性能优化这是一个比较大的话题,在《由12306.cn谈谈网站性能技术》中从业务和设计上说过一些可用的技术以及那些技术的优缺点,今天,想从一些技术细节上谈谈性能优化,主要是一些代码级别的技术和方法。...
  • 算法优化工程师

    2021-08-10 16:51:00
    嵌入式算法移植优化-CUDA编程 嵌入式算法移植优化-CPU,GPU,TPU,NPU都是什么 嵌入式算法移植优化-模型压缩与剪枝 ...嵌入式算法移植优化-openmp(多核编程框架) 附: 打印输出等级控制,方便调试及发布版本 ...
  • Unity3D优化--

    2017-03-31 18:34:30
    项目进入了中期后就需要对程序在移动设备上的表现做分析评估和针对性的优化了,首先前期做优化,很多瓶颈没表现出来,能做的东西不多,而且很多指标会凭预想,如果后期做优化又会太晚,到时候发现一些问题改起来返工...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,831
精华内容 2,732
关键字:

我的世界多核优化