比特币钱包下载|qbs
作者： 比特币钱包下载
2024-03-07 20:44:26
QPS、TPS、并发用户数、吞吐量关系 - 知乎
QPS、TPS、并发用户数、吞吐量关系 - 知乎首发于Linux高薪集训营切换模式写文章登录/注册QPS、TPS、并发用户数、吞吐量关系Wayne1、QPSQPS Queries Per Second 是每秒查询率 ,是一台服务器每秒能够相应的查询次数，是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准, 即每秒的响应请求数，也即是最大吞吐能力。2、TPSTPS Transactions Per Second 也就是事务数/秒。一个事务是指一个客户机向服务器发送请求然后服务器做出反应的过程。客户机在发送请求时开始计时，收到服务器响应后结束计时，以此来计算使用的时间和完成的事务个数，3、QPS和TPS区别个人理解如下：1、Tps即每秒处理事务数，包括了用户请求服务器 服务器自己的内部处理 服务器返回给用户这三个过程，每秒能够完成N个这三个过程，Tps也就是N；2、Qps基本类似于Tps，但是不同的是，对于一个页面的一次访问，形成一个Tps；但一次页面请求，可能产生多次对服务器的请求，服务器对这些请求，就可计入“Qps”之中。例子：例如：访问一个页面会请求服务器3次，一次放，产生一个“T”，产生3个“Q”例如：一个大胃王一秒能吃10个包子，一个女孩子0.1秒能吃1个包子，那么他们是不是一样的呢？答案是否定的，因为这个女孩子不可能在一秒钟吃下10个包子，她可能要吃很久。这个时候这个大胃王就相当于TPS，而这个女孩子则是QPS。虽然很相似，但其实是不同的。4、并发数并发数（并发度）：指系统同时能处理的请求数量，同样反应了系统的负载能力。这个数值可以分析机器1s内的访问日志数量来得到5、吐吞量吞吐量是指系统在单位时间内处理请求的数量，TPS、QPS都是吞吐量的常用量化指标。系统吞吐量要素一个系统的吞吐量（承压能力）与request（请求）对cpu的消耗，外部接口，IO等等紧密关联。单个request 对cpu消耗越高，外部系统接口，IO影响速度越慢，系统吞吐能力越低，反之越高。重要参数QPS(TPS),并发数，响应时间QPS(TPS)：每秒钟request/事务 数量并发数：系统同时处理的request/事务数响应时间：一般取平均响应时间关系QPS(TPS)=并发数/平均响应时间一个系统吞吐量通常有QPS(TPS),并发数两个因素决定，每套系统这个两个值都有一个相对极限值，在应用场景访问压力下，只要某一项达到系统最高值，系统吞吐量就上不去了，如果压力继续增大，系统的吞吐量反而会下降，原因是系统超负荷工作，上下文切换，内存等等其他消耗导致系统性能下降。6、PVPV（Page View）：页面访问量，即页面浏览量或点击量，用户每次刷新即被计算一次。可以统计服务一天的访问日志得到。 7、UV UV（Unique Visitor）：独立访客，统计1天内访问某站点的用户数。可以统计服务一天的访问日志并根据用户的唯一标识去重得到。响应时间（RT）：响应时间是指系统对请求作出响应的时间，一般取平均响应时间。可以通过Nginx、Apache之类的Web Server得到。 8、DAUDAU(Daily Active User)，日活跃用户数量。常用于反映网站、互联网应用或网络游戏的运营情况。DAU通常统计一日（统计日）之内，登录或使用了某个产品的用户数（去除重复登录的用户），与UV概念相似 9、MAUMAU(Month Active User)：月活跃用户数量，指网站、app等去重后的月活跃用户数量10、系统吞吐量评估我们在做系统设计的时候就需要考虑CPU运算，IO，外部系统响应因素造成的影响以及对系统性能的初步预估。而通常情况下，我们面对需求，我们评估出来的出来QPS，并发数之外，还有另外一个维度：日pv。通过观察系统的访问日志发现，在用户量很大的情况下，各个时间周期内的同一时间段的访问流量几乎一样。比如工作日的每天早上。只要能拿到日流量图和QPS我们就可以推算日流量。通常的技术方法：1、找出系统的最高TPS和日PV，这两个要素有相对比较稳定的关系（除了放假、季节性因素影响之外）2、通过压力测试或者经验预估，得出最高TPS，然后跟进1的关系，计算出系统最高的日吞吐量。B2B中文和淘宝面对的客户群不一样，这两个客户群的网络行为不应用，他们之间的TPS和PV关系比例也不一样。11、软件性能测试的基本概念和计算公式软件做性能测试时需要关注哪些性能呢？首先，开发软件的目的是为了让用户使用，我们先站在用户的角度分析一下，用户需要关注哪些性能。对于用户来说，当点击一个按钮、链接或发出一条指令开始，到系统把结果已用户感知的形式展现出来为止，这个过程所消耗的时间是用户对这个软件性能的直观印 象。也就是我们所说的响应时间，当相应时间较小时，用户体验是很好的，当然用户体验的响应时间包括个人主观因素和客观响应时间，在设计软件时，我们就需要 考虑到如何更好地结合这两部分达到用户最佳的体验。如：用户在大数据量查询时，我们可以将先提取出来的数据展示给用户，在用户看的过程中继续进行数据检 索，这时用户并不知道我们后台在做什么。用户关注的是用户操作的相应时间。其次，我们站在管理员的角度考虑需要关注的性能点。1、 响应时间2、 服务器资源使用情况是否合理3、 应用服务器和数据库资源使用是否合理4、 系统能否实现扩展5、 系统最多支持多少用户访问、系统最大业务处理量是多少6、 系统性能可能存在的瓶颈在哪里7、 更换那些设备可以提高性能8、 系统能否支持7×24小时的业务访问再次，站在开发（设计）人员角度去考虑。1、 架构设计是否合理2、 数据库设计是否合理3、 代码是否存在性能方面的问题4、 系统中是否有不合理的内存使用方式5、 系统中是否存在不合理的线程同步方式6、 系统中是否存在不合理的资源竞争来源： https://juejin.im/post/5c2cb5e15188257a937fbfaf?utm_source=gold_browser_extension 编辑于 2021-04-30 14:41高性能服务器吞吐量高并发赞同 15414 条评论分享喜欢收藏申请转载文章被以下专栏收录Linux高薪集训营专注分享Linux技术进阶文章Linux高薪集训营专注分享Linux技术进
Qt 编译方式之 qbs-CSDN博客
>Qt 编译方式之 qbs-CSDN博客
Qt 编译方式之 qbs
最新推荐文章于 2023-11-16 15:56:28 发布
lucky-billy
最新推荐文章于 2023-11-16 15:56:28 发布
阅读量1.2w
收藏
14
点赞数
8
分类专栏：
Qt
文章标签：
QBS
Qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34139994/article/details/98478648
版权
Qt
专栏收录该内容
43 篇文章
226 订阅
订阅专栏
作者：billy 版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处
QBS简介
QBS（Qt Build Suite）同 qmake、cmake 之类一样都是构建工具。QBS 号称是下一代的构建工具(博主的理解上一代是基于 makefile 的构建工具)。根据官网介绍，Qbs 极有可能会替代 qmake 成为 Qt 6.0 的构建系统，与 qmake 相比，Qbs 提供了更快构建速度，以及更多的特性。
和qmake不一样，qbs没有绑定Qt版本，它从项目文件的高级项目描述中生成一个正确的编译表（依赖表）。而传统的MakeFile生成工具比如qmake和CMake生成了makefile文件，然后将实际的命令留给make或者ninja这样的工具去执行。Qbs的另一方面就是充当了并行生成与直接调用编译器、连接器以及其他工具的角色，非常像SCons和Ant做的事情。
Declarative语言
qbs的语法是一个简化版本的qml，提供了对IDE友好的软件项目的展示。它同样提供了自由使用任何JavaScript表达式进行属性绑定的支持。 万事从 “Hello world” 开始，我们创建一个最基础的程序来看下 qbs 如何构建项目：
consoleApplication: true 代表了这是一个控制台程序。 files: “main.cpp” 则列出了源文件(不仅仅只是 C++头文件和源文件) 多个文件时：files: [“foo.h”, “foo.cpp”, “main.cpp”] fileTagsFilter: “application” 代表的意思就是 CppApplication 的 type 属性为 “application”， CppApplication 是一个可执行程序，常用的类型还有 dynamiclibrary(动态库)、staticlibrary 静态库。
Group 将一组在某些行为上是一样的文件组合成一组，比如某些将安装到同一目录下的文件。 Group 分组的对象是文件，如果 Group 项内没有指定有效文件，那么这个 Group 是会被忽略的。 Group 项指定文件可以用 files 属性或 fileTagsFilter 属性，这两个属性是互斥的只能用其一。 files: 指定文件列表。 fileTagsFilter: 指定文件标记名，通过标记名来匹配文件。
qbs Property Documentation
architecture : string 目标平台的处理器体系结构。 未定义表示目标平台独立于体系结构（例如clr或jvm），此属性通常在配置文件中设置。 常用值为：“x86”、“x86_64”和“arm”，默认：未定义。 architectures : stringList 产品将为其构建的体系结构。 默认值：Android上是[armv5te]，与苹果平台上的xcode相同，否则等同于[qbs.architecture]。 buildVariant : string 构建模式的名称。 可能的值是“debug”和“release”。如果 qbs.configurationname 为“release”，则默认为“release”，否则为“debug”。 buildVariants : stringList 构建模式的名称列表。 默认值：相当于[qbs.buildvariant]。 debugInformation : bool 是否生成调试信息。 默认值：对于调试版本为true，否则为false。 enableDebugCode : bool 是否在产品中启用调试功能。不要与生成调试符号或代码优化级别混淆。 通常，此属性对 debug 启用，对 release 禁用。 默认值：对于调试版本为true，否则为false。 hostOS : stringList 此属性由QBS内部设置，并指定OS QBS正在运行。 此属性的可能值是TargetOS的值，即使其中某些值可能不受支持，默认：未定义。 hostPlatform : string 主机平台，注：不要使用此属性。 默认：自动确定。 install : bool 是否安装某组文件。 此属性通常设置在组项中，以将多个文件标记为可安装。 注意：启用此属性的项目将自动接收文件标记“installable”。这对于编写与包装相关的规则很有用，默认值：false installDir : string 产品或组文件的安装目录。 此属性的值是相对于InstallPrefix的路径，默认：未定义 installPrefix : string 全局安装前缀。它隐式地预加在installdir的所有值之前。 此属性本身的值在安装上下文中相对于InstallRoot，默认：[] installRoot : string 全局安装根目录。 在安装上下文中，它隐式地预加了installPrefix的所有值。 注意：此属性与InstallDir和InstallPrefix有根本不同，因为它对正在构建的代码不可见。实际上，install根目录通常只是用于打包二进制文件的临时位置，因此不应假定它们在运行时位于该位置。出于同样的原因，通常不从项目文件中设置此属性。默认值：/install-root installSourceBase : string 要安装的本地文件的基目录。 从installdir中指定的目标目录路径中省略源基目录。 默认：要安装的当前文件的目录，相对于产品的源目录。 nullDevice : string 与空设备对应的平台特定文件路径。 默认值：在Windows上为“nul”，在Unix上为/dev/null。 optimization : string 所有工具链都应执行的一般优化类型。 允许值为： “fast” “none” “small” 默认值：调试版本为“none”，发布版本为“fast”。 pathListSeparator : string 环境变量或其他上下文中使用的路径列表的平台特定分隔符。 在Windows上默认为“；”，在Unix上默认为“：”。 profiles : stringList 构建产品的配置文件。 对于这里列出的每个概要文件，将根据各自概要文件中设置的属性构建一个产品实例。 默认值：[project.profile] shellPath : path 与命令行解释器对应的平台特定文件路径。 在Windows上，这是保存在comspec环境变量（通常是c:/windows/system32/cmd.exe）中的cmd.exe的路径，在类Unix平台上，这是/bin/sh。 默认值：Windows上"%COMSPEC%"，Unix上“bin/sh” sysroot : string 目标平台的sysroot。 此属性通常设置在用于交叉编译的配置文件中。默认：未定义 targetOS : stringList 指定要为其生成项目的操作系统。 使用此属性在条件中测试特定OS或OS系列。请勿为此目的使用TargetPlatform。 可能的值包括“bsd”、“darwin”和“unix”中的一个或多个，以及targetform的可能值。 默认：未定义 targetPlatform : stringList 要为其生成项目的操作系统。 此属性通常设置在配置文件中或特定产品中，目标操作系统始终是已知的（例如以本机代码编写的Apple Watch应用程序）。通常应将此属性视为只写，并避免使用它来测试当前目标操作系统。 可能的值包括以下一个或多个：
"aix"
"android"
"freebsd"
"haiku"
"hpux"
"hurd"
"integrity"
"ios"
"ios-simulator"
"linux"
"lynx"
"macos"
"netbsd"
"openbsd"
"qnx"
"solaris"
"tvos"
"tvos-simulator"
"vxworks"
"watchos"
"watchos-simulator"
"windows"
默认：未定义
toolchain : stringList 工具链的属性用于构建。 典型值包括“llvm”，以及toolchaintype的可能值。默认：未定义 toolchainType : string 工具链用于构建。 通常应将此属性视为只写，并避免使用它来测试当前的工具链。 典型值包括：“gcc”、“clang”、“mingw”、“msvc”和“xcode”。 默认：自动确定。 [read-only] configurationName : string 当前生成配置的名称。 构建配置是通过命令行参数config设置的。默认：“default” [read-only] hostOSBuildVersion : string 主机操作系统的内部版本。 目前，仅为Windows和Apple平台定义，默认：未定义 在Windows上，这是4位或5位Windows内部版本号，相当于versionPatch。 在苹果平台上，这是苹果版本控制方案中的标准版本号。例如，“13C64”。 [read-only] hostOSVersion : string 主机操作系统版本。 目前，仅为Windows和Apple平台定义， 默认：未定义 由两个或三个由点分隔的数字组成。例如，“10.9”或“6.3.9600”。 [read-only] hostOSVersionParts : list 主机操作系统版本列表。 例如，Windows8.1（版本6.3.9600）对应的值为[6，3，9600]，默认：[] [read-only] hostOSVersionMajor : int 主机操作系统主版本。 默认值：hostoVersionParts[0] [read-only] hostOSVersionMinor : int 主机操作系统次版本。 默认值：hostosVersionParts[1] [read-only] hostOSVersionPatch : int 主机操作系统修补程序级别。 默认值：hostosVersionParts[2] [read-only] version : string QBS版本号。例如，“1.4.1”。 [read-only] versionMajor : int QBS的主要版本号。 [read-only] versionMinor : int QBS的次要版本号。 [read-only] versionPatch : int QBS的补丁版本号。
Group QML Type
condition : bool 确定组中的文件是否实际视为项目的一部分。默认值：true excludeFiles : list 从文件列表中减去的文件列表。使用通配符时很有用。默认：一个空的列表 fileTags : list 要附加到组文件的文件标记列表。然后可以用一个规则来匹配它们。 注意：文件标记器从不应用于设置了此属性的文件。默认：一个空的列表 fileTagsFilter : list 要匹配的artifact.filetags列表。 此组中设置的任何属性都将应用于产品的工件，其文件标记与此处列出的标记匹配。 组的file tags属性指定的文件标记将添加到匹配的项目中。此属性与文件互斥。 默认：一个空的列表 files : list 组中的文件。与FileTagsFilter互斥。 使用包含组项的文件的父目录解析相对路径。但是，如果prefix属性设置为绝对路径，则该路径将成为基目录。默认：一个空的列表 filesAreTargets : bool 如果此属性为true且组位于模块中，则组中的文件将不会成为依赖于模块的产品的源工件。相反，它们被视为产品的目标工件。也就是说，它们将与依赖模块的产品中的规则的inputsFromDependencies文件标记列表相匹配。默认值：false name : string 组的名称。不在内部使用；主要用于IDE。 默认值：“Group x”，其中x是产品中所有组中的唯一数字。 overrideTags : bool 确定如何处理同时在产品（或父组，如果有）和组的顶级列出的文件上的标记。 如果此属性为真，则通过组设置的文件标记将替换通过产品或父组设置的标记。如果为假，则将组标记添加到父标记中。如果设置了FileTagsFilter，则忽略此属性。默认值：true prefix : string 用于预处理所有文件的字符串。允许斜杠并具有目录语义。 默认值：父组的前缀（如果存在），否则为空。
案例
通常我们使用Group 指定安装文件的目标目录。 要安装一组文件，请将该组的 qbs.install 属性设置为true，qbs.installdir 的值指定文件安装目录的路径。可以将所有安装目录的基目录指定为 qbs.installPrefix 的值。 例如，以下属性指定在Windows和Linux上安装一组QML文件和应用程序可执行文件的位置：
Application {
name: "myapp"
Group {
name: "Runtime resources"
files: "*.qml"
qbs.install: true
qbs.installDir: condition: qbs.targetOS.contains("unix")
? "share/myapp" : "resources"
}
Group {
name: "The App itself"
fileTagsFilter: "application"
qbs.install: true
qbs.installDir: "bin"
}
qbs.installPrefix: condition: qbs.targetOS.contains("unix")
? "usr/local" : "MyApp"
}
在Windows上，qml文件最终将安装在myapp\resources中，应用程序可在myapp\bin中执行。 在Linux上，qml文件将安装在/usr/local/share/myapp中，可执行文件将安装在/usr/local/bin中。
前景
这是一个试验性质的项目，用来试验不同编译工具概念。qmake仍然会存在很长一段时间，并且没人会强迫谁去使用qbs，或者其它任何编译工具。尽管在某些时候我们肯定会尝试将qbs作为Qt自身的编译系统来使用。
通用元编译工具，比如CMake或者GNU Autotools的用户也许注意到了，严谨来说，qbs与跨平台编译工具相比有一个关键部分的缺失：适应宿主环境，就是所谓的配置检查。当前，qbs仍然需要一个外部的配置脚本来生成一个JSON格式的文件，从而能被qbs调用。但是这终究不是一个长久的解决方法。关键点在于使配置测试像其他模块一样可用。其实现当然不止包括了Declarative，还包含了一些JavaScript代码。
关注博主即可阅读全文
优惠劵
lucky-billy
关注
关注
8
点赞
踩
14
收藏
觉得还不错?
一键收藏
知道了
1
评论
Qt 编译方式之 qbs
作者：billy版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处QBS简介QBS（Qt Build Suite）同 qmake、cmake 之类一样都是构建工具。QBS 号称是下一代的构建工具(博主的理解上一代是基于 makefile 的构建工具)。Qbs 将会替代 qmake 成为 Qt 6.0 的构建系统，与 qmake 相比，Qbs 提供了更快构建速度，以...
复制链接
扫一扫
专栏目录
Qt Creator设置Qbs
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-16
1002
Qt Creator设置Qbs设置Qbs构建Qbs指定Qbs设置
设置Qbs
要使用Qbs构建项目，必须为该项目创建.qbs文件。您可以使用Qt Creator创建使用Qbs构建的C或C ++项目。
该应用程序是使用与构建和运行套件关联的默认Qbs配置文件构建的。Qt Creator自动为每个套件创建一个Qbs配置文件。您可以通过添加新的键和值来编辑构建配置文件。
要检查使用哪个Qbs版本，请选择“工具” >“选项” >“ Qbs” >“常规”。
构建Qbs
如果您是从Qt Creator
qbs：用于软件项目的现代构建工具
02-05
质量
Qbs是一种构建自动化工具，旨在方便地管理跨多个平台的软件项目的构建过程。 Qb可以用于任何软件项目，而与所使用的编程语言，工具包或库无关。
文献资料
Qbs产品文档位于
该项目的主页是
支持平台
Qbs二进制文件可用于Windows，macOS，Linux和FreeBSD。
有关如何在平台上安装Qb的更多信息，请参见文档中的“页面。
Qbs允许针对不同平台构建应用程序，有关受支持平台的列表以及每个平台的详细信息，请参阅“页面。
建筑Qbs
有关从源代码构建Qb的信息，请参阅 。
报告错误
请在我们的报告所有错误。
贡献
请参阅
1 条评论
您还未登录，请先
登录
后发表或查看评论
qbs-shared：共享的Qbs导入和模块
02-05
qbs分享了
使用qbs构建系统的项目共享的导入和模块。
依存关系
您需要 > = 1.11.0来构建此项目。
安装
Qbs是一个新的构建系统，与qmake或CMake相比，它更易于使用。
如果您想了解更多信息，请阅读，特别是以及如何从安装工件。
从存储库的根目录运行：
qbs setup-toolchains --type gcc /usr/bin/g++ gcc
qbs setup-qt /usr/bin/qmake-qt5 qt5
qbs config profiles.qt5.baseProfile gcc
然后，从存储库的根目录运行：
qbs -d build -j $(
qt5-qbs:用于构建Qt5的QBS项目
05-18
QBS上的Qt
关于该项目
该项目探索了使用QBS（link）构建Qt的有用性，目标是创建更快的基础版本，开发Qt时缩短迭代时间，受益于Qt Creator在使用QBS时提供的改进的开发人员体验以及移植到新平台的目的。通过绕过修改configure / qmake的传统要求，可以更轻松地进行操作。
该项目分为两部分：Qt宿主工具和Qt库。 Qt宿主工具可以针对开发环境构建一次，而无需为随后编译的每个Qt副本重建（只要Qt的版本在宿主工具和库之间保持同步）。 这样做的好处是，主机工具不会与任何单个目标Qt构建绑定在一起。
命令行宿主工具qhost用于模拟qmake的查询功能。 这使QBS可以依次使用由这组QBS文件创建的Qt构建。
QBS> = 1.4.0是必需的。
用法
假设您在QBS设置中安装了非Qt配置文件。 例如，这可以是您的系统工具链配置文件。
Qt本身的前提条件相同，只是
Qt-Qbs-Application:Qt Qbs应用程序样板和有用的脚本
05-17
Qt-Qbs-应用程序
Qt Qbs应用程序样板和有用的脚本
浅谈Qt的编译方式：qmake/cmake/qbs及qbs被弃用的原因
$firecat利白的代码足迹$
03-08
2万+
1、Qbs简介
https://doc.qt.io/qbs/qml-qbsmodules-qbs.html
https://blog.csdn.net/qq_34139994/article/details/98478648
QBS（Qt Build Suite）同 qmake、cmake 之类一样都是构建工具。QBS 号称是新一代的构建工具，比qmake编译速度更快。
和qmake不一样......
Qt构建工具QBS之一 ——从一个简单的工程开始
ajmq96356的博客
02-24
516
在这篇文章中通过在一个简单的工程初步了解 Qbs 是怎么构建一个工程的, 涉及到的语言项有 Product, Application, CppApplication, Depends, FileTagger, Group. 涉及到的模块有 cpp 和 qbs 模块.
创建一个简单的工程
按下列步骤创建一个简单的工程, 本系列文章都将基于这个工程来做讲解实验.
打开 Qt C...
qbs java_Qt构建工具QBS之零 —— QBS 概览
weixin_39757040的博客
02-27
853
本系列文章起因自己非常喜欢 QT 这个框架, 使用 QT 这几年, IDE 一直是使用的 QT 自带的 Qt Creator, 这个 IDE 本身比较轻巧, 同事相关的语法提示之类的也算够用, 但是 qmake 有的时候就显得不那么只能了, 有时非得手动qmake一下才行, 有时需要清除再构建, 有时这两者合一起也不一定解决问题. 需要删除构建目录才行. 很多新手学习的时候, 经常会再论坛或群里问...
QT入门---项目创建步骤
qq_62271524的博客
08-12
336
相较于 qmake 和 CMake，qbs 更加模块化和可扩展，可以更方便地进行高级构建任务，如自动化部署和资源管理。qmake：qmake 是 Qt 提供的默认构建系统工具，它使用 .pro 文件来描述项目的配置和构建规则。qmake 是 Qt 的传统构建工具，易于上手和使用。综上所述，qmake 是 Qt 的默认构建工具，CMake 是一个通用的跨平台构建系统工具，而 qbs 是 Qt 引入的新型构建工具。在 Qt 开发中，qmake、CMake 和 qbs 都是用于构建和管理项目的工具。
分布式专题1-了解分布式
Wizard的博客
07-29
517
前言
我是一名工作时间不长但是也不短的java民工。因为在小城市发展，所以程序开发仅仅是单机就能搞定一切业务啦。这也导致自己能力停滞不前。写这个专栏不仅仅是为了拓宽视野，同时也希望能够增长一些知识。本专栏是我一边不断学习一边总结的结果，可能有不对的地方，如有发现请及时告知，万分感激！因为也是作为初学者，所以专栏对于新手来说可能较为友好，我会将我学习过程中遇到的疑问一一列出来，尽自己全...
并发基础
qq_43121090的博客
06-03
247
操作系统 进程 线程之间的关系
操作系统是包含多个进程的容器 每个进程容纳多个线程的容器
什么是进程
Process 指的是程序的一次执行。在用户下达运行程序的命令后,就会产生进程
进程是程序的真正运行实例,是资源分配的基本单位
什么是线程
线程是CPU的基本调度单位,每个线程执行的都是进程代码的某个片段
进程和线程的不同
起源不同
先有的进程 后有的线程
线程的诞生是为了提高程序的运行效率
概念不同
进程 一个程序运行的实例 是资源分配的基本单位
线程 是CPU调度的基本单位
内
qps,tps,并发量，pv，uv
最新发布
weixin_53667158的博客
11-16
237
例如，访问一个 Index 页面会请求服务器 3 次，包括一次 html，一次 css，一次 js，那么访问这一个页面就会产生一个T，产生三个Q。可以统计服务一天的访问日志得到。qps：Queries Per Second，每秒查询率，一台服务器每秒能够响应的查询次数，每秒的响应请求数。不使用缓存：大约8核16G机器，qps 400多，如果横向扩展，10台8核16g的机器，qps大约4000多。一个系统的吞吐量（承压能力）与request（请求）对cpu的消耗，外部接口，IO等等紧密关联。
Qt构建工具QBS之零 —— QBS 概览
ajmq96356的博客
02-24
503
本系列文章起因
自己非常喜欢 QT 这个框架, 使用 QT 这几年, IDE 一直是使用的 QT 自带的 Qt Creator, 这个 IDE 本身比较轻巧, 同事相关的语法提示之类的也算够用, 但是 qmake 有的时候就显得不那么只能了, 有时非得手动qmake一下才行, 有时需要清除再构建, 有时这两者合一起也不一定解决问题. 需要删除构建目录才行. 很多新手学习的时候, 经...
Qt Quick 和qml介绍
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-23
1806
qml入门
Tiled的qbs方式编译记录
yantuguiguziPGJ的博客
05-12
333
以qbs方式将qml自动打包OK。
Qt & Qbs | 配置cpp版本、cpp11、cpp17
u011607490的博客
12-17
1222
在CppApplication里添加配置
cpp.cxxLanguageVersion: "c++17"
c++其他版本同理
import qbs
CppApplication {
consoleApplication: true
files: "main.cpp"
Group { // Properties for the produced exec...
redis的qps
mimsmile的博客
07-16
8822
1.单机的redis一般是支持上万甚至几万，具体的性能取决于数据操作的复杂性，如果仅仅是简单的kv操作的话，可以达到数万，如果是运行复杂的lua脚本的话，就可能只能到一万左右
2.缓存一般是用来支撑读的高并发，一般比较少用来支撑读的操作，一般读的操作是比较频繁的，甚至达到几万几十万，但是写的操作每秒才几千，这就需要读写分离了；
架构一般做成主从架构：
master：负责写数据，master数据写入...
Qt Creator下载和安装(详细教程)
热门推荐
win_turn的博客
01-05
52万+
简介Qt是跨平台的图形开发库，目前由Digia全资子公司 Qt Company 独立运营，官方网址：
http://www.qt.io/
也可以访问Qt项目域名：http://qt-project.org/
Qt本身支持众多操作系统。从通用操作系统Linux、Windows，到手机系统Android、iOS、WinPhone，嵌入式系统支持QNX、VxWorks，应用非常广泛。
基于Qt的
qt6源码编译工具集合
06-28
在Qt 6中，qmake已经被一个新的构建系统qbs替代，但我们仍然可以使用qmake来编译Qt 6的源码。确保安装了Qt工具包并可以通过命令行调用qmake。 另外，为了成功编译Qt 6源码，我们需要安装一些依赖项。Qt 6有一些核心...
“相关推荐”对你有帮助么？
非常没帮助
没帮助
一般
有帮助
非常有帮助
提交
lucky-billy
CSDN认证博客专家
CSDN认证企业博客
码龄8年
暂无认证
165
原创
1756
周排名
5701
总排名
73万+
访问
等级
7713
积分
4万+
粉丝
2003
获赞
866
评论
6942
收藏
私信
关注
热门文章
60道逻辑推理题及答案
78338
Qt之QGraphicsView入门篇
75939
Qt之QGraphicsView实战篇
42604
Qt之QGraphicsView进阶篇
32395
C++中static变量的初始化
24079
分类专栏
C++
10篇
Python
25篇
Maya
1篇
OpenCV
5篇
Qt
43篇
QML
39篇
设计模式
34篇
其他
12篇
最新评论
Qt设置软件的使用期限
qq_36587956:
大佬求一份源码非常感谢 1139724958@qq.com
Qt设置软件的使用期限
weixin_42344653:
大佬求一份源码谢谢你！499656714@qq.con
Qt之QGraphicsView实战篇
李率旗:
大佬我也想求个源码非常感谢！3051937803@qq.com
Qt调用工业相机之映美精相机
jzling2333:
为啥我下载安装之后没有Samples文件夹
Qt设置软件的使用期限
姜维字伯约:
作者可以发一份源码给我吗,2043427275@qq.com
您愿意向朋友推荐“博客详情页”吗？
强烈不推荐
不推荐
一般般
推荐
强烈推荐
提交
最新文章
21天定制减肥食谱
QML 中实现国际化翻译
QML 项目中使用 Qt Design Studio 生成的UI界面
2024年4篇
2023年13篇
2022年1篇
2021年40篇
2020年60篇
2019年47篇
目录
目录
分类专栏
C++
10篇
Python
25篇
Maya
1篇
OpenCV
5篇
Qt
43篇
QML
39篇
设计模式
34篇
其他
12篇
目录
评论 1
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
祝福语
请填写红包祝福语或标题
红包数量
个
红包个数最小为10个
红包总金额
元
红包金额最低5元
余额支付
当前余额3.43元
前往充值 >
需支付：10.00元
取消
确定
下一步
知道了
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝
规则
hope_wisdom 发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额
0
抵扣说明：
1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。
余额充值
Qt构建工具QBS之零 —— QBS 概览 - findumars - 博客园
Qt构建工具QBS之零 —— QBS 概览 - findumars - 博客园
会员
周边
新闻
博问
AI培训
云市场
所有博客
当前博客
我的博客
我的园子
账号设置
简洁模式 ...
退出登录
注册
登录
朝闻道
Delphi是天赐的礼物，C++/Qt也是神器，不多做一些产品，对不起天下人
CnBlogs
Home
New Post
Contact
Admin
Subscription
Qt构建工具QBS之零 —— QBS 概览
本系列文章起因
自己非常喜欢 QT 这个框架, 使用 QT 这几年, IDE 一直是使用的 QT 自带的 Qt Creator, 这个 IDE 本身比较轻巧, 同事相关的语法提示之类的也算够用, 但是 qmake 有的时候就显得不那么只能了, 有时非得手动qmake一下才行, 有时需要清除再构建, 有时这两者合一起也不一定解决问题. 需要删除构建目录才行. 很多新手学习的时候, 经常会再论坛或群里问, 为什么我的代码和书上的一模一样, 怎么构建时就出错呢? 这种情况, 大多是 qmake “抽风”了. 其实 QBS 刚出来的时候就想试试, 但是被那个自带文档吓住了. 这个春节, 无意中打开 QBS 的文档, 仔细看了下. 同时实践了下, 原来这个东西还是很简单的. 鉴于目前网上对 QBS 的中文资料好像一篇都没有, 特意整理了下自己学习过程中的心得分享出来. 一来可以让自己对 QBS 的认识更加系统, 二来也给有需要的人一个参考.
QBS 总体认识
QBS 即 Qt Build Suite. 同 qmake, cmake 之类一样, 都是构建工具. QBS 号称是下一代的构建工具(我的理解是上一代是基于 makefile 的构建工具?). 不过个人认为, 至少和 qmake 比, 还是要好用很多. 首先文档就比qmake好些, 其次 QBS 的可扩展性真的很强大且易于使用.
QBS 项目文件使用一种类 QML 语言编写的, 其实就是 QML 的简化版, 对于已经学会 QML 的人理解 QBS 应该会更简单(可惜我就不会QML). 对了这是一种声明式语言, 对于习惯了命令式编程语言的, 需要转变下思维, 其实会发现声明式其实更简单.
按 QBS 的自带文档, QBS 的知识可以分 3 大块, 即语言项(Language Item), 模块(Module), 以及其它如 QBS 内建提供的服务之类的. 其中最后一块的知识比较简单, 一般查下文档就会用了. 而模块又是由一系列的语言项组成的. 所以最重要的就是语言项了. 语言项和模块的关系就像 C++ 和 库(例如STL, Qt 等的关系). 对于这些预定义的模块, 基本上在用的时候查下模块相应属性的用法即可.
本系列文章, 没有说明 QBS 命令行的用法, 因为我本人是直接使用 Qt Creator 中自带集成的 QBS. 本系列文章, 是面向写 Qt 程序的, 对于平台 Windows 和 Linux 下基本是一致的, 但对于 Mac/iOS, Andorid 的相关语言项是忽略掉的(因为我不会). 还有关于编译 Java 语言的语言项也会忽略.
语言项概述
上面讲到 QBS 的基础是语言项, QBS 文档列出的语言项共有 30 个, 看起来挺多, 但是以后你会知道, 实际使用到的仅有十多个. 下面是我加单的分了下类, 列出了所有的语言项.
注: 本篇文章, 只是对 QBS 有个大概的介绍, 无需记住或拼命的理解什么.
Project 和 SubProject
Project 项在结构上是所有语言项的最顶层的(最外围的)那个语言项, 一个 Project 项包含了一个或多个 Product 项. 同时 Project 项中还能嵌套包含 Project 项.
SubProject 项用来将一个 Project 项加入到当前的 Project项中, 将其作为当前项目的一个子项目.
Project/SubProject 项作用类似与 qmake 项目文件中(pro文件) 定义 TEMPLATE = subdirs.
Product
Application
CppApplication
QtApplication
QtGuiApplication
XPCService
ApplicationExtension
DynamicLibrary
StaticLibrary
JavaClassCollection
JavaJarCollection
AndroidApk
LoadableModule
一个 Product 项就是在构件过程最终生产的结果, 比如可以是一个: 可执行的应用程序, 动态库, 或是静态库等等. 如上列出所示, 从 Product 项又派生出了 Application, DynamicLibrary, StaticLibrary 等项. 但其本质还是 Product 项, 只是为了使用上更方便, 在 Product 项上预设了一些属性和依赖. 例如: Application 项, 也可以如下 Product 项来表示
Product {
type: "application"
// ...
}
1
2
3
4
1
2
3
4
Product 项及其派生的各种项作用类似与定义了 TEMPLATE = app, TEMPLATE = lib 等的 qmake 项目文件.
FileTagger, Group 和 Properties
FileTagger 项用来标记(源)文件的类别, 即标记出哪些文件是 C++ 源码, 哪些文件是资源文件等等, 有点类似于 Windows 系统上的文件扩展名的作用, 但是比扩展名强大的多.
Group 项用来分组(源)文件, 比如在 Windows 平台和 Linux 平台上需要包含不同的文件时就可以用 Group 项来分组. 如下:
Application {
Group {
name: "Windows files"
condition: targetOS.contains("windows")
files: "myclass_win_impl.cpp"
}
Group {
name: "Linux files"
condition: targetOS.contains("linux")
files: "myclass_linux_impl.cpp"
}
}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
Properties 项则是用来分组属性的. 用法类似于 Group, 只是一个作用于文件, 一个作用于属性.
Depends, Module 和 Export
Depends 项用来引入功能模块(Module).
Module 项用来定义一个模块, 模块可能包含一系列属性, 规则, 变换等等.
Export 项可以将 Product 中的一系列属性导出, 使得这个 Product 能够像 Module 一样由 Depends 引入使用.
Artifact, Rule 和 Transformer
Artifact 项, 即工件, 构建过程以及构建最终产生的文件都称之为工件. 工件由规则(Rule) 和 变换 (Transformer)产生.
Rule/Transformer 项, 将输入文件生成一个或多个工件.
其它项: AutotestRunner, InstallPackage, Probe, PropertyOptions, Scanner
略
小结
为了对 QBS 对上述语言项更好的理解. 可以用一个 C++ 项目来类比:
Project 和 SubProject 就项就像项目的工程文件一样, 对于简单的项目, 比如 Hello World 程序, 就一个源文件, 不要工程文件也是可以的. 但是对于有很多源文件的, 还包含各种资源文件时, 还是有必要通过工程文件来管理的.
Product 项及其派生项, 有点项 main, WinMain, DllMain, 之类的入口函数, 决定了最后生成的是什么东西(控制台程序, windows程序, 动态库).
FileTagger, Group 和 Properties 项有点项 C/C++ 中哪些用来条件编译的预处理指令.
Depends, Module 和 Export 有点像引入/定义库文件.
Artifact, Rule 和 Transformer 则项最后开始编译程序的编译命令行, 以及生成的中间文件和最终的程.
为了怕吓住大家, 再次告诉大家 QBS 虽然很强大, 但是也是很简单的. 比如上面看到列出那么多语言项, 其实很多功能上是重复/相似的, 可以不用的, 还有很多是用不到的. 比如上面第 2 类中的 Product 系总共有13个, 我只用到了CppApplication, DynamicLibrary 和 StaticLibrary 三个. 即使你真的都能用到, 那么它们的用法也是一样的, 换个名字而已.
下一篇文章开始正式开始使用 QBS 来构建项目, 并讲解其中出现的语言项.
转载请加上原文链接, 并保证文章的完整性. 鉴于自己的能力可能有表达失当或者错误的地方, 希望大家包含. 如您能提出意见或建议, 本人不甚感激.li_wey AT 163.com
http://blog.csdn.net/ysu533/article/details/50728815
posted @
2016-08-17 06:20
findumars
Views(4036)
Comments(0)
Edit
收藏
举报
会员力量，点亮园子希望
刷新页面返回顶部
公告
Copyright © 2024 findumars
Powered by .NET 8.0 on Kubernetes
qbs介绍
qbs介绍
Back
Developers
Developers
Price. Buy.
Download. Try.
Qt Blog
Latest Blogs
Select Category
Categories
qt-labs-chinese (122)
Qt (65)
qt-blogs-chinese (40)
qtearth-blogs-chinese (27)
Qt Quick (24)
qt-quarterly-chinese (21)
嵌入式 (19)
Qt Creator (15)
C++ (11)
OpenGL (11)
News (10)
Qt Quick 2 (9)
Releases (9)
macOS (9)
Contributors (8)
Performance (8)
Windows (8)
Announcements (6)
Graphics (6)
Build system (5)
KDE (5)
Qt 5 (5)
Symbian (5)
WebKit (5)
Community (4)
Labs (4)
Open Governance (4)
Qt Script (4)
Biz Circuit (3)
Dev Loop (3)
Hot Topic (3)
Lighthouse (3)
Maemo (3)
Metal (3)
Network (3)
Painting (3)
Qt Simulator (3)
S60 (3)
Vulkan (3)
Android (2)
Automotive (2)
Cloud (2)
Compilers (2)
Design (2)
Desktop (2)
Direct3D (2)
Embedded (2)
Events (2)
GammaRay (2)
Graphics Dojo (2)
HTTP (2)
Internet (2)
QPA (2)
Qt 3D Studio (2)
Qt Design Studio (2)
Qt Project (2)
Qt Quick 3D (2)
Qt for Automation (2)
Qt for MCUs (2)
Qt for WebAssembly (2)
QtMobility (2)
Roadmap (2)
Web (2)
3D (1)
Accessibility (1)
Automation (1)
Background (1)
Biz Circuit & Dev Loop (1)
Clang (1)
Clazy (1)
Cross platform (1)
Debugging (1)
Docker (1)
Enginio (1)
Framework (1)
Functional Safety (1)
Git (1)
HMI (1)
HotSpot (1)
IoT (1)
KDAB (1)
Layouts (1)
Linux (1)
MQTT (1)
Marketplace (1)
MeeGo (1)
Meet Qt (1)
Multimedia (1)
MyScript (1)
Photoshop (1)
Pinned (1)
Q&A (1)
QBS (1)
QLALR (1)
QML (1)
QML Live (1)
QNetworkAccessManager (1)
Qt 3D (1)
Qt 5.11 (1)
Qt Automotive Suite (1)
Qt Design Tools (1)
Qt Mobility (1)
Qt Web Runtime (1)
Qt3D (1)
QtWebKit (1)
RTOS (1)
Sketch (1)
Sponsership (1)
Testing (1)
UI (1)
UI Design (1)
UI Development (1)
UI Tools (1)
UX (1)
Virtual Keyboard (1)
WebAssembly (1)
WebGL (1)
Websockets (1)
apitrace (1)
benchmark (1)
business、Forrester、project management (1)
container (1)
handwriting (1)
httpserver (1)
iOS (1)
linguist (1)
threaded (1)
topic alias (1)
Select Month
Archives
March 2011 (12)
April 2013 (12)
February 2011 (10)
April 2011 (8)
May 2013 (7)
July 2013 (7)
June 2013 (6)
January 2011 (5)
December 2018 (5)
January 2020 (5)
December 2010 (4)
August 2011 (4)
July 2012 (4)
June 2020 (4)
October 2011 (3)
February 2012 (3)
March 2012 (3)
April 2012 (3)
March 2013 (3)
October 2013 (3)
April 2018 (3)
November 2018 (3)
June 2019 (3)
August 2019 (3)
September 2013 (2)
November 2013 (2)
December 2013 (2)
January 2019 (2)
May 2019 (2)
July 2019 (2)
February 2020 (2)
March 2020 (2)
April 2020 (2)
May 2020 (2)
May 2011 (1)
September 2011 (1)
November 2011 (1)
May 2012 (1)
June 2012 (1)
August 2012 (1)
December 2012 (1)
March 2014 (1)
April 2014 (1)
May 2014 (1)
December 2014 (1)
February 2015 (1)
June 2018 (1)
July 2018 (1)
August 2018 (1)
October 2018 (1)
March 2019 (1)
April 2019 (1)
October 2019 (1)
November 2019 (1)
December 2019 (1)
Subscribe
Subscribe to Our Blog
Stay up to date with the latest marketing, sales and service tips and news.
Subscribe via Email
Subscribe via Email
< Back to other options
Back to Blog home
qbs介绍
Published on 星期二 二月 21, 2012 by Zhen Zeng
in
Build system
qt-labs-chinese
| Comments
原文链接：Jörg － Introducing qbs
多年来我们对qmake产生了一种爱恨交织的感情。一方面它确实能工作，另一方面它也有一些怪癖，因此被广泛地认为无法维护下去了。博文 [TMQB] 包含了一个有希望取代qmake的方法的列表。我们研究了市面上的各种各样的工具，但是没有一个能符合我们的需求 - 详见 [WNCM] 。所以不久之前我们启动了一个内部项目用以实验一些新的想法，成果就是：Qt编译套件，qbs(读作 "Qubes")
它不是qmake
和qmake不一样，qbs没有绑定Qt版本，它从项目文件的高级项目描述中生成一个正确的编译表（依赖表）。同样，传统的MakeFile生成工具比如qmake和CMake生成了makefile文件，然后将实际的命令留给make或者ninja这样的工具去执行。Qbs的另一方面就是充当了并行生成与直接调用编译器、连接器以及其他工具的角色，非常像SCons和Ant做的事情。
Declarative语言
qbs的语法是一个简化版本的qml，提供了对IDE友好的软件项目的展示。它同样提供了自由使用任何JavaScript表达式进行属性绑定的支持。项目文件编辑器能够理解如何对纯字符串数组文字进行处理。对于更复杂的结构，项目文件编辑器能够“回滚”，使用文本编辑器打开项目文件。
files: ["foo.h", "foo.cpp", "main.cpp"] // 可从 IDE 编辑
files: generateFileList().concat(["extra.cpp"]) // 只能在文本编辑器中处理
对于大多数应用场景来说，可以编写对IDE友好的的项目文件。如果你需要更多的控制，你也可以自由的释放你高超的JavaScript技巧。 现在我们来看一个必须的“Hello World”项目：
// helloworld.qbp
import qbs.base 1.0
CppApplication {
name: "HelloWorld"
files: "main.cpp"
}
import语句使我们可以使用类似“Application”一样的项目，我们给项目起名为“Hello World”，并添加了一个C++源文件。
语言的详细部分说明在文档的“语言介绍”中。
可扩展性
在 qmke中进行代码生成与资源编译相关操作是大家想尽量避免的。而在qbs里，你可以很容易地编写一些规则来将一种特定类型的文件转换为另外一种。qbs既可以调用一个外部工具（例如：rcc）来进行转换操作，也可以直接用内含的JavaScript来转换。下面是一个简单的例子，演示了如何将Qt Creator源码树的.pluginspec.in文件转换为.pluginspec文件。
Rule {
...
prepare: {
var cmd = new JavaScriptCommand();
cmd.description = "generating " + FileInfo.fileName(output.fileName);
cmd.qtcreator_version = product.module.qtcreator_version;
cmd.sourceCode = function() {
var inf = new TextFile(input.fileName);
var all = inf.readAll();
all = all.replace(new RegExp('\$\$QTCREATOR_VERSION(?!w)', 'g'), qtcreator_version);
var file = new TextFile(output.fileName, TextFile.WriteOnly);
file.write(all);
file.close();
}
return cmd;
}
}
快速增量编译
qbs将项目视为整体因此不会为它划分成子项目。就算是只编译项目的一部分，整个编译图表都会纳入考虑范围当中。不会再出现循环生成的问题了（参见： [RMCH]）。
采用这种方式还有一个好处就是可以使得增量编译的速度比生成操作要快得多。我修改了来自[QPBS]的基准生成脚本，添加了qbs的支持。下述的测试结果来自一个增量编译的项目，项目包含了200个库，每个库50个类，每个文件有50个库内包含以及10个库外包含。
在我的机器上，进行没有修改任何生成文件的增量编译操作耗时： 实际 0m4.076s 用户 0m2.556s 系统 0m1.952s qbs 下同样操作耗时： 实际 0m0.843s 用户 0m0.724s 系统 0m0.112s
编译说明
说得够多了。我如何能获取它？怎么编译它？
git clone git://gitorious.org/qt-labs/qbs.git
cd qbs
qmake -r qbs.pro
make
make docs
请先阅读文档，尤其是“配置qbs”部分。在线版本可以访问这里。然后你就可以开始试试/qbs/tests/manual下面的例子了。如果需要一个现实点的项目例子，可以在这里找到为Qt Creator而写的qbs项目文件。
qbs项目欢迎贡献者，参考Qt-Project 词条中的“Setting up Gerrit”。gerrit远程地址是
qbs项目的邮件列表是： http://lists.qt-project.org/mailman/listinfo/qbs
前景
这是一个试验性质的项目，用来试验不同编译工具概念。qmake仍然会存在很长一段时间，并且没人会强迫谁去使用qbs，或者其它任何编译工具。尽管在某些时候我们肯定会尝试将qbs作为Qt自身的编译系统来使用。
通用元编译工具，比如CMake或者GNU Autotools的用户也许注意到了，严谨来说，qbs与跨平台编译工具相比有一个关键部分的缺失：适应宿主环境，就是所谓的配置检查。当前，qbs仍然需要一个外部的配置脚本来生成一个JSON格式的文件，从而能被qbs调用。但是这终究不是一个长久的解决方法。关键点在于使配置测试像其他模块一样可用。其实现当然不止包括了Declarative，还包含了一些JavaScript代码。
目前还有很多需要做的工作！非完整的想法列表可以通过我们的缺陷跟踪器查看（当我们的管理员将这个项目设为公众开放的时候）。
引用
[RMCH] Peter Miller (1998), “Recursive Make Considered Harmful”, AUUGN Journal of AUUG Inc., 19(1), pp. 14-25 [TMQB] Marius Storm-Olsen (2009), “To make, or not to make – QMake and beyond”, http://labs.qt.nokia.com/2009/10/12/to-make-or-not-to-make-qmake-and-beyond/ [WNCM] http://lists.qt.nokia.com/pipermail/qt5-feedback/2011-June/000494.html [QPBS] Noel Llopis (2005), “The Quest for the Perfect Build System”, http://gamesfromwithin.com/the-quest-for-the-perfect-build-system
Don't forget to share this post!
Subscribe to Our Blog
Stay up to date with the latest marketing, sales and service tips and news.
I want the latest in...
Related Articles
Qt Quick 3D介绍：Qt Quick的高级3D API
使用Docker 对Qt for WebAssembly进行测试
QLALR探险——使用QLALR生成一个文字探险游戏的解析器
Try Qt 6.0 Now!
Download the latest release here: www.qt.io/download.
Qt 6 was created to be the productivity platform for the future, with next-gen 2D & 3D UX and limitless scalability.
Visit the Qt Resource Center
Find webinars, use cases, tutorials, videos & more at resources.qt.io
We're Hiring
Check out all our open positions here and follow us on Instagram to see what it's like to be #QtPeople.
Näytä tämä julkaisu Instagramissa.
Want to build something for tomorrow, join #QtPeople today! We have loads of cool jobs you don’t want to miss! http://qt.io/careers #builtwithQt #software #developers #coding #framework #tool #tooling #C++ #QML #engineers #sales #tech #technology #UI #UX #CX #Qt #Qtdev #global #openpositions #careers #job
Henkilön Qt (@theqtcompany) jakama julkaisu Marras 1, 2017 kello 7.40 PDT
Contact Us
Qt Group
我们的故事
品牌
新闻
人才招聘
投资者
Qt开发产品
质量保证产品
许可证
开源版本
计划和定价
下载
常见问题
学习Qt
针对学习者
针对学校和教师
Qt文档
Qt论坛
支持与服务
客户成功案例
支持服务
合作伙伴
Qt World
© 2024 The Qt Company
Legal Notice
Privacy Policy
Terms & Conditions
Trust Center
Cookie Settings
Email Preferences
Qt Group includes The Qt Company Oy and its global subsidiaries and affiliates.
Qbs Manual
Qbs Manual
Back to Qt.io
Contact Us
Blog
Download Qt
Archives
Snapshots
Introduction
Setup
Usage
How-tos
Reference
Appendix A: Building Qbs
Appendix B: Migrating from Other Build Systems
Appendix C: The JSON API
Appendix D: Code Attributions
Search
Introduction
Qbs Manual
Version 2.2.1
Qbs is a tool that helps simplify the build process for developing projects across multiple platforms. Qbs can be used for any software project, regardless of programming language, toolkit, or libraries used.
Note: Please report bugs and suggestions to the Qt Bug Tracker.
Introduction
Setup
Installing
Configuring Profiles and Preferences
Managing Qt Versions
Usage
Language Introduction
Building Applications
Running Applications
Installing Files
Target Platforms
Using the Shell
Generators
Multiplexing
Custom Modules and Items
Special Property Values
Module Providers
How-tos
Reference
List of All Items
List of Language Items
List of Convenience Items
List of Probes
List of Built-in Services
Command-Line Interface
List of Modules
List of Module Providers
Command and JavaScriptCommand
Appendix A: Building Qbs
Appendix B: Migrating from Other Build Systems
Appendix C: The JSON API
Appendix D: Licenses and Code Attributions
Introduction
© 2023 The Qt Company Ltd.
Documentation contributions included herein are the copyrights of
their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd in Finland and/or other countries worldwide. All other trademarks are property
of their respective owners.
Next
Introduction
Contact Us
Company
About Us
Investors
Newsroom
Careers
Office Locations
Licensing
Terms & Conditions
Open Source
FAQ
Support
Support Services
Professional Services
Partners
Training
For Customers
Support Center
Downloads
Qt Login
Contact Us
Customer Success
Community
Contribute to Qt
Forum
Wiki
Downloads
Marketplace
Sign In
Feedback
© 2023 The Qt Company
Introduction | Qbs Manual
Introduction | Qbs Manual
Back to Qt.io
Contact Us
Blog
Download Qt
Archives
Snapshots
Qbs 2.2.1
Introduction
Setup
Usage
How-tos
Reference
Appendix A: Building Qbs
Appendix B: Migrating from Other Build Systems
Appendix C: The JSON API
Appendix D: Code Attributions
Search
Qbs Manual
Introduction
Qbs Manual
Setup
Introduction
Qbs is a build automation tool designed to conveniently manage the build process of software projects across multiple platforms.
Features
Qbs provides the following benefits:
Declarative paradigm
Well-defined language
Platform and programming language independence
Correct and fast incremental builds
Extensible architecture
Easy integration to IDEs
Declarative Paradigm
When writing a project, it is important to describe the build tasks and dependencies between them, rather than the build order. It is difficult to determine the correct build order in complex projects, especially during parallel builds. The build tool should bear that burden, not the developer.
With a declarative language, Qbs enables you to express intent rather than specifying single build steps. This provides the appropriate level of abstraction for a build system. For example, dependencies can be created between products, such that the target artifacts of the dependency can be used as input to the build rules in the context of the depending product. In addition, you can export dependencies and properties to other products.
Qbs is modular with clean interfaces between modules. A module is a collection of properties and language items that are used for building a product if the product depends on the module. The properties that can be set for a module are used to control the behavior of the toolchain used to build the module.
Qbs itself knows nothing about file types or extensions, and therefore all source files in a product are handled equally. However, you can assign file tags to an artifact to act as markers or to specify a file type. Qbs applies a rule to the source files of the project and chooses the ones that match the input file tags specified by the rule. It then creates artifacts in the build graph that have other filenames and file tags.
Products and projects can contain probes that are run prior to building, for instance to locate dependent headers, libraries, and other files outside the project directory.
Well-Defined Language
Qbs projects are specified in a QML dialect. QML is a concise, easy to learn, and intuitive language that is used successfully in the Qt project. Its core is declarative, but it can be extended with JavaScript snippets for extra flexibility.
Qbs builds applications based on the information in a project file. Each project file specifies one project that can contain several products. You specify the type of the product, such as an application, and the dependencies the product has on other products.
The product type determines the set of rules that Qbs applies to produce artifacts from input files. The input files can be divided into groups according to their type or purpose, for example. A group can also be used to attach properties to products.
The following is an example of a minimal project file that specifies the product type, application name, source file, and a dependency on the cpp module:
Application {
name: "helloworld"
files: "main.cpp"
Depends { name: "cpp" }
}
For more information, see Language Introduction.
Platform and Programming Language Independence
Qbs can be used for any software project, regardless of programming language, toolkit, or libraries used. Qbs has built-in support for building applications for Windows, Linux, macOS, Android, iOS, tvOS, watchOS, QNX, and FreeBSD, as well as for cross-compilation. It can be easily extended to support further platforms.
Invoking qbs build from the command line automatically builds the project for the current host platform using the best available toolchain and settings, unless a default profile is set. You can configure additional profiles for each toolchain you want to use and select the profile to use at build time.
For example, to build applications for Android devices, you would need to set up a profile for the Android toolchain and select it when you build the application. If you name the profile Android, you would then enter the following command:
qbs build profile:Android
For more information, see Building Applications.
Platform and programming language support is implemented as a set of modules that your product depends on. In the language example above, the dependency on the cpp module determines that the C++ sources are compiled and linked into a binary.
Alternatively, you could use the CppApplication convenience item that implies a dependency on the cpp module:
CppApplication {
name: "helloworld"
files: "main.cpp"
}
Additionally, if the sources use Qt, you need a dependency to the Qt.core module, and so on.
In addition to building projects, Qbs can install the build artifacts to a location from where they can be run on the desktop or on a device. Qbs modules can be used to create installers for the end users of the applications. For example, the dmg module contains properties and rules for building Apple Disk Images, which are typically used to distribute applications and installers on macOS. The innosetup, nsis, and wix modules contain properties and rules for building installers for Windows platforms.
Correct and Fast Incremental Builds
Qbs is an all-in-one tool that generates a build graph from a high-level project description (like qmake or CMake) and additionally undertakes the task of executing the commands in the low-level build graph (like make).
Qbs automatically takes advantage of multi-processor and multi-core systems to achieve maximum build parallelization. By default, running qbs without any arguments is roughly equivalent to running make -j
Qbs has knowledge about the whole project, and therefore builds remain correct even when you build sub-projects, because Qbs ensures that all dependencies are built too. This virtually eliminates the need for clean builds.
Qbs uses dynamic build graphs with build rules that can generate a variable number of files and that are executed only when needed. When figuring out which rules to execute, Qbs starts at the product type and then looks for a way to produce artifacts with matching file tags from source files, using a chain of rules that are connected by their respective input and output tags. For an example of how rules are applied when building products, see Rules and Product Types.
The Qbs build rules can produce a variable number of outputs. If the input changes, only the required rules are applied at build time. If a rule is applied, all the dependent rules are applied as well, but only those. This feature ensures the correctness of the build graph after source code changes without having to re-configure the whole project.
Changing properties that do not affect the build, because they are not used by rules, will not cause the project to be rebuilt. The use of properties is tracked. Generated artifacts that cease to exist are deleted to avoid picking outdated generated artifacts and indefinitely increasing the size of the build directory.
Fast incremental builds are crucial for a fast edit-build-run cycle. Instead of retrieving the timestamps of generated files, Qbs uses the time stamps stored in the build graph. This is especially important on Windows, where file system operations are slow.
If the project files were not changed, the build graph is loaded from disk. It is stored in a binary format that can be loaded much faster than the real project files. The project files are parsed only if they were changed.
Extensible Architecture
You can create your own custom modules and items and make Qbs aware of them.
You store the custom modules and items in a subdirectory of the project directory and specify the path to the subdirectory as a value of the qbsSearchPaths property. For example, if the custom module is located at my-modules/modules/modulename/modulename.qbs, you would specify it in the project file as follows:
Project {
qbsSearchPaths: "my-modules"
For more information, see Custom Modules and Items.
IDE Integration
Qbs can be used not only from the command line, but also in combination with an IDE, such as Qt Creator or Visual Studio Code. These IDEs directly support Qbs projects using the new Qbs session feature. Thus, these IDEs can retrieve all the information required to build a single file or project through a session's JSON protocol API.
In addition, Qbs can generate projects for Visual Studio, IAR EW, and Keil uVision, but it still is an experimental option. For more information, see Generators.
Qt Creator
Qt Creator provides accurate information about the build progress and displays a project tree that reflects the logical structure of the project, instead of presenting low-level information, such as the file system structure. Adding or removing source files keeps the existing project file structure intact.
For more information about using Qbs to build projects from Qt Creator, see Setting Up Qbs.
Visual Studio Code
Visual Studio Code provides the qbs-community plugin that provides accurate information about the build progress and displays a project tree that reflects the logical structure of the project. Also, it can provide low-level information, such as the file system structure.
For more information about using Qbs to build projects from Visual Studio Code, see How To.
Build Process
The build process of a product starts by examining the type property of the product. It contains a list of file tags that are similar to MIME types.
The following example product contains one file tag, application:
Product {
Depends { name: "cpp" }
type: ["application"]
files: ["main.cpp", "class.cpp", "class.h"]
}
Qbs then searches through all rules available in the context, meaning rules that are defined in the project or those that are made available through the dependency on a module, such as the compiler and linker rules pulled in from the cpp dependency in the example.
When Qbs finds a rule that produces one or more artifacts with the relevant file tag, it looks at the depencencies of that rule and finds out that it produces artifacts tagged obj. It then finds a rule that produces obj artifacts that takes .cpp artifacts as input.
Module {
// ...
Rule {
inputs: ["cpp"]
Artifact {
filePath: input.fileName + ".o"
fileTags: ["obj"]
}
prepare: {
// g++ -c main.cpp -o main.o ...
}
}
//...
}
There is no rule in the current context that produces .cpp files, but we have defined .cpp files as inputs for the product. When we added a dependency on the cpp module, that dependency also pulled in another Qbs primitive called the file tagger. The file tagger looked for files matching the pattern *.cpp, and then applied the cpp tag to those input files:
Module {
// ...
FileTagger {
patterns: "*.cpp"
fileTags: ["cpp"]
}
//...
}
Since the .cpp files are input files, they by definition have no other dependencies, and we can go back the opposite way in the tree starting with the compiler rule described above.
This design works well for generated files. The .cpp artifacts could come from another rule that produced them by processing some other input, either instead of or in addition to the raw files listed in the product.
The compiler rule will be invoked twice, once for each .cpp file, producing a separate object file for each one. Then the linker rule will be invoked. Its multiplex property is set to true, which means that instead of producing one output per input and invoking the rule multiple times, all input will be collected before invoking the rule only once to produce the final application object.
The standard versus multiplex rules map well to the compiler and linker processes. The compiler takes one input file to produce one output file, whereas the linker takes multiple input files to produce one output file.
Finally, after the linker rule has been invoked, it produces an artifact tagged application. Because the product's type property did not contain other file tags, the build process is now complete.
Qbs Manual
Setup
© 2023 The Qt Company Ltd.
Documentation contributions included herein are the copyrights of
their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd in Finland and/or other countries worldwide. All other trademarks are property
of their respective owners.
Contents
Features
Declarative Paradigm
Well-Defined Language
Platform and Programming Language Independence
Correct and Fast Incremental Builds
Extensible Architecture
IDE Integration
Build Process
Next
Setup
Previous
Qbs Manual
Contact Us
Company
About Us
Investors
Newsroom
Careers
Office Locations
Licensing
Terms & Conditions
Open Source
FAQ
Support
Support Services
Professional Services
Partners
Training
For Customers
Support Center
Downloads
Qt Login
Contact Us
Customer Success
Community
Contribute to Qt
Forum
Wiki
Downloads
Marketplace
Sign In
Feedback
© 2023 The Qt Company
Installing | Qbs Manual
Installing | Qbs Manual
Back to Qt.io
Contact Us
Blog
Download Qt
Archives
Snapshots
Qbs 2.2.1
Introduction
Setup
Usage
How-tos
Reference
Appendix A: Building Qbs
Appendix B: Migrating from Other Build Systems
Appendix C: The JSON API
Appendix D: Code Attributions
Search
Qbs Manual
Installing
Setup
Configuring Profiles and Preferences
Installing
Qbs binaries are available for Windows, macOS, Linux, and FreeBSD.
On all platforms, Qbs binaries are part of the Qt Creator and Qt SDK installers. You can find the qbs executable in the bin directory of Qt Creator, or within the application bundle's MacOS directory on macOS.
Qbs can also be built locally from sources. For more information, see Appendix A: Building Qbs.
Windows
The Qt Project provides prebuilt binaries for Windows (x86 and x64) at https://download.qt.io/official_releases/qbs/. For commercial customers of The Qt Company, the binaries are available in the Qt Account. The binaries are packaged in a .zip folder that can be extracted to a location of your choice.
Qbs is also available as a Chocolatey package, which can be installed in the usual way:
choco install qbs
The .nupkg file can also be downloaded directly from https://download.qt.io/official_releases/qbs/ for offline installation.
macOS
Qbs can be conveniently installed on macOS with the MacPorts or Homebrew package managers:
brew install qbs
or
port install qbs
Linux and FreeBSD
Qbs is available via the package management systems of Linux distributions, and FreeBSD.
Setup
Configuring Profiles and Preferences
© 2023 The Qt Company Ltd.
Documentation contributions included herein are the copyrights of
their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd in Finland and/or other countries worldwide. All other trademarks are property
of their respective owners.
Contents
Windows
macOS
Linux and FreeBSD
Next
Configuring Profiles and Preferences
Previous
Setup
Contact Us
Company
About Us
Investors
Newsroom
Careers
Office Locations
Licensing
Terms & Conditions
Open Source
FAQ
Support
Support Services
Professional Services
Partners
Training
For Customers
Support Center
Downloads
Qt Login
Contact Us
Customer Success
Community
Contribute to Qt
Forum
Wiki
Downloads
Marketplace
Sign In
Feedback
© 2023 The Qt Company
Qbs
Qbs
Qbs
Blog
Documentation
Get Qbs
Qbs Manual
Installing
Qbs 2.1.1
Setup
Configuring Profiles and Preferences
Contents
Windows
macOS
Linux and FreeBSD
Installing
Qbs binaries are available for Windows, macOS, Linux, and FreeBSD.
On all platforms, Qbs binaries are part of the Qt Creator and Qt SDK installers. You can find the qbs executable in the bin directory of Qt Creator, or within the application bundle's MacOS directory on macOS.
Qbs can also be built locally from sources. For more information, see Appendix A: Building Qbs.
Windows
The Qt Project provides prebuilt binaries for Windows (x86 and x64) at https://download.qt.io/official_releases/qbs/. For commercial customers of The Qt Company, the binaries are available in the Qt Account. The binaries are packaged in a .zip folder that can be extracted to a location of your choice.
Qbs is also available as a Chocolatey package, which can be installed in the usual way:
choco install qbs
The .nupkg file can also be downloaded directly from https://download.qt.io/official_releases/qbs/ for offline installation.
macOS
Qbs can be conveniently installed on macOS with the MacPorts or Homebrew package managers:
brew install qbs
or
port install qbs
Linux and FreeBSD
Qbs is available via the package management systems of Linux distributions, and FreeBSD.
Setup
Configuring Profiles and Preferences