Stephan Avenwedde 发布的文章

如果你知道如何在 C++ 中使用输入输出(I/O)流,那么(原则上)你便能够处理任何类型的输入输出设备。

 title=

在 C++ 中,对文件的读写可以通过使用输入输出流与流运算符 >><< 来进行。当读写文件的时候,这些运算符被应用于代表硬盘驱动器上文件类的实例上。这种基于流的方法有个巨大的优势:从 C++ 的角度,无论你要读取或写入的内容是文件、数据库、控制台,亦或是你通过网络连接的另外一台电脑,这都无关紧要。因此,知道如何使用流运算符来写入文件能够被转用到其他领域。

输入输出流类

C++ 标准库提供了 ios\_base 类。该类作为所有 I/O 流的基类,例如 basic\_ofstreambasic\_ifstream。本例将使用读/写字符的专用类型 ifstreamofstream

  • ofstream:输出文件流,并且其能通过插入运算符 << 来实现。
  • ifstream:输入文件流,并且其能通过提取运算符 >> 来实现。

该两种类型都是在头文件 <fstream> 中所定义。

ios_base 继承的类在写入时可被视为数据接收器,在从其读取时可被视为数据源,与数据本身完全分离。这种面向对象的方法使 关注点分离 separation of concerns 依赖注入 dependency injection 等概念易于实现。

一个简单的例子

本例程是非常简单:实例化了一个 ofstream 来写入,和实例化一个 ifstream 来读取。

#include <iostream> // cout, cin, cerr etc...
#include <fstream> // ifstream, ofstream
#include <string>


int main()
{
    std::string sFilename = "MyFile.txt";    

    /******************************************
     *                                        *
     *                WRITING                 *
     *                                        *
     ******************************************/

    std::ofstream fileSink(sFilename); // Creates an output file stream

    if (!fileSink) {
        std::cerr << "Canot open " << sFilename << std::endl;
        exit(-1);
    }

    /* std::endl will automatically append the correct EOL */
    fileSink << "Hello Open Source World!" << std::endl;


    /******************************************
     *                                        *
     *                READING                 *
     *                                        *
     ******************************************/
   
    std::ifstream fileSource(sFilename); // Creates an input file stream

    if (!fileSource) {
        std::cerr << "Canot open " << sFilename << std::endl;
        exit(-1);
    }
    else {
        // Intermediate buffer
        std::string buffer;

        // By default, the >> operator reads word by workd (till whitespace)
        while (fileSource >> buffer)
        {
            std::cout << buffer << std::endl;
        }
    }

    exit(0);
}

该代码可以在 GitHub 上查看。当你编译并且执行它时,你应该能获得以下输出:

 title=

这是个简化的、适合初学者的例子。如果你想去使用该代码在你自己的应用中,请注意以下几点:

  • 文件流在程序结束的时候自动关闭。如果你想继续执行,那么应该通过调用 close() 方法手动关闭。
  • 这些文件流类继承自 basic\_ios(在多个层次上),并且重载了 ! 运算符。这使你可以进行简单的检查是否可以访问该流。在 cppreference.com 上,你可以找到该检查何时会(或不会)成功的概述,并且可以进一步实现错误处理。
  • 默认情况下,ifstream 停在空白处并跳过它。要逐行读取直到到达 EOF ,请使用 getline(...) 方法。
  • 为了读写二进制文件,请将 std::ios::binary 标志传递给构造函数:这样可以防止 EOL 字符附加到每一行。

从系统角度进行写入

写入文件时,数据将写入系统的内存写入缓冲区中。当系统收到系统调用 sync 时,此缓冲区的内容将被写入硬盘。这也是你在不告知系统的情况下,不要卸下 U 盘的原因。通常,守护进程会定期调用 sync。为了安全起见,也可以手动调用 sync()

#include <unistd.h> // needs to be included

sync();

总结

在 C++ 中读写文件并不那么复杂。更何况,如果你知道如何处理输入输出流,(原则上)那么你也知道如何处理任何类型的输入输出设备。对于各种输入输出设备的库能让你更容易地使用流运算符。这就是为什么知道输入输出流的流程会对你有所助益的原因。


via: https://opensource.com/article/21/3/ccc-input-output

作者:Stephan Avenwedde 选题:lujun9972 译者:wyxplus 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

通过这个分步教程,开始用人类可读的文本编写 WebAssembly。

 title=

WebAssembly 是一种字节码格式,几乎所有的浏览器 都可以将它编译成其宿主操作系统的机器代码。除了 JavaScript 和 WebGL 之外,WebAssembly 还满足了将应用移植到浏览器中以实现平台独立的需求。作为 C++ 和 Rust 的编译目标,WebAssembly 使 Web 浏览器能够以接近原生的速度执行代码。

当谈论 WebAssembly 应用时,你必须区分三种状态:

  1. 源码(如 C++ 或 Rust): 你有一个用兼容语言编写的应用,你想把它在浏览器中执行。
  2. WebAssembly 字节码: 你选择 WebAssembly 字节码作为编译目标。最后,你得到一个 .wasm 文件。
  3. 机器码(opcode): 浏览器加载 .wasm 文件,并将其编译成主机系统的相应机器码。

WebAssembly 还有一种文本格式,用人类可读的文本表示二进制格式。为了简单起见,我将其称为 WASM-text。WASM-text 可以比作高级汇编语言。当然,你不会基于 WASM-text 来编写一个完整的应用,但了解它的底层工作原理是很好的(特别是对于调试和性能优化)。

本文将指导你在 WASM-text 中创建经典的 “Hello World” 程序。

创建 .wat 文件

WASM-text 文件通常以 .wat 结尾。第一步创建一个名为 helloworld.wat 的空文本文件,用你最喜欢的文本编辑器打开它,然后粘贴进去:

(module
    ;; 从 JavaScript 命名空间导入
    (import  "console"  "log" (func  $log (param  i32  i32))) ;; 导入 log 函数
    (import  "js"  "mem" (memory  1)) ;; 导入 1 页 内存(64kb)
   
    ;; 我们的模块的数据段
    (data (i32.const 0) "Hello World from WebAssembly!")
   
    ;; 函数声明:导出 helloWorld(),无参数
    (func (export  "helloWorld")
        i32.const 0  ;; 传递偏移 0 到 log
        i32.const 29  ;; 传递长度 29 到 log(示例文本的字符串长度)
        call  $log
        )
)

WASM-text 格式是基于 S 表达式的。为了实现交互,JavaScript 函数用 import 语句导入,WebAssembly 函数用 export 语句导出。在这个例子中,从 console 模块中导入 log 函数,它需要两个类型为 i32 的参数作为输入,以及一页内存(64KB)来存储字符串。

字符串将被写入偏移量 为 0 的数据段。数据段是你的内存的 叠加投影 overlay ,内存是在 JavaScript 部分分配的。

函数用关键字 func 标记。当进入函数时,栈是空的。在调用另一个函数之前,函数参数会被压入栈中(这里是偏移量和长度)(见 call $log)。当一个函数返回一个 f32 类型时(例如),当离开函数时,一个 f32 变量必须保留在栈中(但在本例中不是这样)。

创建 .wasm 文件

WASM-text 和 WebAssembly 字节码是 1:1 对应的,这意味着你可以将 WASM-text 转换成字节码(反之亦然)。你已经有了 WASM-text,现在将创建字节码。

转换可以通过 WebAssembly Binary Toolkit(WABT)来完成。从该链接克隆仓库,并按照安装说明进行安装。

建立工具链后,打开控制台并输入以下内容,将 WASM-text 转换为字节码:

wat2wasm helloworld.wat -o helloworld.wasm

你也可以用以下方法将字节码转换为 WASM-text:

wasm2wat helloworld.wasm -o helloworld_reverse.wat

一个从 .wasm 文件创建的 .wat 文件不包括任何函数或参数名称。默认情况下,WebAssembly 用它们的索引来识别函数和参数。

编译 .wasm 文件

目前,WebAssembly 只与 JavaScript 共存,所以你必须编写一个简短的脚本来加载和编译 .wasm 文件并进行函数调用。你还需要在 WebAssembly 模块中定义你要导入的函数。

创建一个空的文本文件,并将其命名为 helloworld.html,然后打开你喜欢的文本编辑器并粘贴进去:

<!DOCTYPE  html>
<html>
  <head>
    <meta  charset="utf-8">
    <title>Simple template</title>
  </head>
  <body>
    <script>
   
      var memory = new  WebAssembly.Memory({initial:1});

      function  consoleLogString(offset, length) {
        var  bytes = new  Uint8Array(memory.buffer, offset, length);
        var  string = new  TextDecoder('utf8').decode(bytes);
        console.log(string);
      };

      var  importObject = {
        console: {
          log:  consoleLogString
        },
        js : {
          mem:  memory
        }
      };
     
      WebAssembly.instantiateStreaming(fetch('helloworld.wasm'), importObject)
      .then(obj  => {
        obj.instance.exports.helloWorld();
      });
     
    </script>
  </body>
</html>

WebAssembly.Memory(...) 方法返回一个大小为 64KB 的内存页。函数 consoleLogString 根据长度和偏移量从该内存页读取一个字符串。这两个对象作为 importObject 的一部分传递给你的 WebAssembly 模块。

在你运行这个例子之前,你可能必须允许 Firefox 从这个目录中访问文件,在地址栏输入 about:config,并将 privacy.file_unique_origin 设置为 true

 title=

注意: 这样做会使你容易受到 CVE-2019-11730 安全问题的影响。

现在,在 Firefox 中打开 helloworld.html,按下 Ctrl+K 打开开发者控制台。

 title=

了解更多

这个 Hello World 的例子只是 MDN 的 了解 WebAssembly 文本格式 文档中的教程之一。如果你想了解更多关于 WebAssembly 的知识以及它的工作原理,可以看看这些文档。


via: https://opensource.com/article/21/3/hello-world-webassembly

作者:Stephan Avenwedde 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在本教程中,教你如何设置和使用 Pythonic 来编程。它是一个图形化编程工具,用户可以很容易地使用现成的函数模块创建 Python 程序。

 title=

然而,不像纽约证券交易所这样的传统证券交易所一样,有一段固定的交易时间。对于加密货币而言,则是 7×24 小时交易,这使得任何人都无法独自盯着市场。

在以前,我经常思考与加密货币交易相关的问题:

  • 一夜之间发生了什么?
  • 为什么没有日志记录?
  • 为什么下单?
  • 为什么不下单?

通常的解决手段是使用加密交易机器人,当在你做其他事情时,例如睡觉、与家人在一起或享受空闲时光,代替你下单。虽然有很多商业解决方案可用,但是我选择开源的解决方案,因此我编写了加密交易机器人 Pythonic。 正如去年 我写过的文章 一样,“Pythonic 是一种图形化编程工具,它让用户可以轻松使用现成的函数模块来创建 Python 应用程序。” 最初它是作为加密货币机器人使用,并具有可扩展的日志记录引擎以及经过精心测试的可重用部件,例如调度器和计时器。

开始

本教程将教你如何开始使用 Pythonic 进行自动交易。我选择 币安 Binance 交易所的 波场 Tron 比特币 Bitcoin 交易对为例。我之所以选择这个加密货币对,是因为它们彼此之间的波动性大,而不是出于个人喜好。

机器人将根据 指数移动平均 exponential moving averages (EMA)来做出决策。

 title=

TRX/BTC 1 小时 K 线图

EMA 指标通常是一个加权的移动平均线,可以对近期价格数据赋予更多权重。尽管移动平均线可能只是一个简单的指标,但我对它很有经验。

上图中的紫色线显示了 EMA-25 指标(这表示要考虑最近的 25 个值)。

机器人监视当前的 EMA-25 值(t0)和前一个 EMA-25 值(t-1)之间的差距。如果差值超过某个值,则表示价格上涨,机器人将下达购买订单。如果差值低于某个值,则机器人将下达卖单。

差值将是做出交易决策的主要指标。在本教程中,它称为交易参数。

工具链

将在本教程使用如下工具:

  • 币安专业交易视图(已经有其他人做了数据可视化,所以不需要重复造轮子)
  • Jupyter 笔记本:用于数据科学任务
  • Pythonic:作为整体框架
  • PythonicDaemon :作为终端运行(仅适用于控制台和 Linux)

数据挖掘

为了使加密货币交易机器人尽可能做出正确的决定,以可靠的方式获取资产的 美国线 open-high-low-close chart OHLC)数据是至关重要。你可以使用 Pythonic 的内置元素,还可以根据自己逻辑来对其进行扩展。

一般的工作流程:

  1. 与币安时间同步
  2. 下载 OHLC 数据
  3. 从文件中把 OHLC 数据加载到内存
  4. 比较数据集并扩展更新数据集

这个工作流程可能有点夸张,但是它能使得程序更加健壮,甚至在停机和断开连接时,也能平稳运行。

一开始,你需要 币安 OHLC 查询 Binance OHLC Query 元素和一个 基础操作 Basic Operation 元素来执行你的代码。

 title=

数据挖掘工作流程

OHLC 查询设置为每隔一小时查询一次 TRXBTC 资产对(波场/比特币)。

 title=

配置 OHLC 查询元素

其中输出的元素是 Pandas DataFrame。你可以在 基础操作 元素中使用 输入 input 变量来访问 DataFrame。其中,将 Vim 设置为 基础操作 元素的默认代码编辑器。

 title=

使用 Vim 编辑基础操作元素

具体代码如下:

import pickle, pathlib, os
import pandas as pd

outout = None

if isinstance(input, pd.DataFrame):
    file_name = 'TRXBTC_1h.bin'
    home_path = str(pathlib.Path.home())
    data_path = os.path.join(home_path, file_name)

    try:
        df = pickle.load(open(data_path, 'rb'))
        n_row_cnt = df.shape[0]
        df = pd.concat([df,input], ignore_index=True).drop_duplicates(['close_time'])
        df.reset_index(drop=True, inplace=True)
        n_new_rows = df.shape[0] - n_row_cnt
        log_txt = '{}: {} new rows written'.format(file_name, n_new_rows)
    except:
        log_txt = 'File error - writing new one: {}'.format(e)
        df = input

    pickle.dump(df, open(data_path, "wb" ))
    output = df

首先,检查输入是否为 DataFrame 元素。然后在用户的家目录(~/)中查找名为 TRXBTC_1h.bin 的文件。如果存在,则将其打开,执行新代码段(try 部分中的代码),并删除重复项。如果文件不存在,则触发异常并执行 except 部分中的代码,创建一个新文件。

只要启用了复选框 日志输出 log output ,你就可以使用命令行工具 tail 查看日志记录:

$ tail -f ~/Pythonic_2020/Feb/log_2020_02_19.txt

出于开发目的,现在跳过与币安时间的同步和计划执行,这将在下面实现。

准备数据

下一步是在单独的 网格 Grid 中处理评估逻辑。因此,你必须借助 返回元素 Return element 将 DataFrame 从网格 1 传递到网格 2 的第一个元素。

在网格 2 中,通过使 DataFrame 通过 基础技术分析 Basic Technical Analysis 元素,将 DataFrame 扩展包含 EMA 值的一列。

 title=

在网格 2 中技术分析工作流程

配置技术分析元素以计算 25 个值的 EMA。

 title=

配置技术分析元素

当你运行整个程序并开启 技术分析 Technical Analysis 元素的调试输出时,你将发现 EMA-25 列的值似乎都相同。

 title=

输出中精度不够

这是因为调试输出中的 EMA-25 值仅包含六位小数,即使输出保留了 8 个字节完整精度的浮点值。

为了能进行进一步处理,请添加 基础操作 元素:

 title=

网格 2 中的工作流程

使用 基础操作 元素,将 DataFrame 与添加的 EMA-25 列一起转储,以便可以将其加载到 Jupyter 笔记本中;

 title=

将扩展后的 DataFrame 存储到文件中

评估策略

在 Juypter 笔记本中开发评估策略,让你可以更直接地访问代码。要加载 DataFrame,你需要使用如下代码:

 title=

用全部小数位表示

你可以使用 iloc 和列名来访问最新的 EMA-25 值,并且会保留所有小数位。

你已经知道如何来获得最新的数据。上面示例的最后一行仅显示该值。为了能将该值拷贝到不同的变量中,你必须使用如下图所示的 .at 方法方能成功。

你也可以直接计算出你下一步所需的交易参数。

 title=

买卖决策

确定交易参数

如上面代码所示,我选择 0.009 作为交易参数。但是我怎么知道 0.009 是决定交易的一个好参数呢? 实际上,这个参数确实很糟糕,因此,你可以直接计算出表现最佳的交易参数。

假设你将根据收盘价进行买卖。

 title=

回测功能

在此示例中,buy_factorsell_factor 是预先定义好的。因此,发散思维用直接计算出表现最佳的参数。

 title=

嵌套的 for 循环,用于确定购买和出售的参数

这要跑 81 个循环(9x9),在我的机器(Core i7 267QM)上花费了几分钟。

 title=

在暴力运算时系统的利用率

在每个循环之后,它将 buy_factorsell_factor 元组和生成的 profit 元组追加到 trading_factors 列表中。按利润降序对列表进行排序。

 title=

将利润与相关的交易参数按降序排序

当你打印出列表时,你会看到 0.002 是最好的参数。

 title=

交易要素和收益的有序列表

当我在 2020 年 3 月写下这篇文章时,价格的波动还不足以呈现出更理想的结果。我在 2 月份得到了更好的结果,但即使在那个时候,表现最好的交易参数也在 0.002 左右。

分割执行路径

现在开始新建一个网格以保持逻辑清晰。使用 返回 元素将带有 EMA-25 列的 DataFrame 从网格 2 传递到网格 3 的 0A 元素。

在网格 3 中,添加 基础操作 元素以执行评估逻辑。这是该元素中的代码:

 title=

实现评估策略

如果输出 1 表示你应该购买,如果输出 2 则表示你应该卖出。 输出 0 表示现在无需操作。使用 分支 Branch 元素来控制执行路径。

 title=

分支元素:网格 3,2A 位置

因为 0-1 的处理流程一样,所以你需要在最右边添加一个分支元素来判断你是否应该卖出。

 title=

分支元素:网格 3,3B 位置

网格 3 应该现在如下图所示:

 title=

网格 3 的工作流程

下单

由于无需在一个周期中购买两次,因此必须在周期之间保留一个持久变量,以指示你是否已经购买。

你可以利用 Stack 元素来实现。顾名思义,栈元素表示可以用任何 Python 数据类型来放入的基于文件的栈。

你需要定义栈仅包含一个布尔类型,该布尔类型决定是否购买了(True)或(False)。因此,你必须使用 False 来初始化栈。例如,你可以在网格 4 中简单地通过将 False 传递给栈来进行设置。

 title=

将 False 变量传输到后续的栈元素中

在分支树后的栈实例可以进行如下配置:

 title=

设置栈元素

在栈元素设置中,将 对输入的操作 Do this with input 设置成 Nothing 。否则,布尔值将被 10 覆盖。

该设置确保仅将一个值保存于栈中(TrueFalse),并且只能读取一个值(为了清楚起见)。

在栈元素之后,你需要另外一个 分支 元素来判断栈的值,然后再放置 币安订单 Binance Order 元素。

 title=

判断栈中的变量

将币安订单元素添加到分支元素的 True 路径。网格 3 上的工作流现在应如下所示:

 title=

网格 3 的工作流程

币安订单元素应如下配置:

 title=

编辑币安订单元素

你可以在币安网站上的帐户设置中生成 API 和密钥。

 title=

在币安账户设置中创建一个 API 密钥

在本文中,每笔交易都是作为市价交易执行的,交易量为 10,000 TRX(2020 年 3 月约为 150 美元)(出于教学的目的,我通过使用市价下单来演示整个过程。因此,我建议至少使用限价下单。)

如果未正确执行下单(例如,网络问题、资金不足或货币对不正确),则不会触发后续元素。因此,你可以假定如果触发了后续元素,则表示该订单已下达。

这是一个成功的 XMRBTC 卖单的输出示例:

 title=

成功卖单的输出

该行为使后续步骤更加简单:你可以始终假设只要成功输出,就表示订单成功。因此,你可以添加一个 基础操作 元素,该元素将简单地输出 True 并将此值放入栈中以表示是否下单。

如果出现错误的话,你可以在日志信息中查看具体细节(如果启用日志功能)。

 title=

币安订单元素中的输出日志信息

调度和同步

对于日程调度和同步,请在网格 1 中将整个工作流程置于 币安调度器 Binance Scheduler 元素的前面。

 title=

在网格 1,1A 位置的币安调度器

由于币安调度器元素只执行一次,因此请在网格 1 的末尾拆分执行路径,并通过将输出传递回币安调度器来强制让其重新同步。

 title=

网格 1:拆分执行路径

5A 元素指向 网格 2 的 1A 元素,并且 5B 元素指向网格 1 的 1A 元素(币安调度器)。

部署

你可以在本地计算机上全天候 7×24 小时运行整个程序,也可以将其完全托管在廉价的云系统上。例如,你可以使用 Linux/FreeBSD 云系统,每月约 5 美元,但通常不提供图形化界面。如果你想利用这些低成本的云,可以使用 PythonicDaemon,它能在终端中完全运行。

 title=

PythonicDaemon 控制台

PythonicDaemon 是基础程序的一部分。要使用它,请保存完整的工作流程,将其传输到远程运行的系统中(例如,通过 安全拷贝协议 Secure Copy SCP),然后把工作流程文件作为参数来启动 PythonicDaemon:

$ PythonicDaemon trading_bot_one

为了能在系统启动时自启 PythonicDaemon,可以将一个条目添加到 crontab 中:

# crontab -e

 title=

在 Ubuntu 服务器上的 Crontab

下一步

正如我在一开始时所说的,本教程只是自动交易的入门。对交易机器人进行编程大约需要 10% 的编程和 90% 的测试。当涉及到让你的机器人用金钱交易时,你肯定会对编写的代码再三思考。因此,我建议你编码时要尽可能简单和易于理解。

如果你想自己继续开发交易机器人,接下来所需要做的事:

  • 收益自动计算(希望你有正收益!)
  • 计算你想买的价格
  • 比较你的预订单(例如,订单是否填写完整?)

你可以从 GitHub 上获取完整代码。


via: https://opensource.com/article/20/4/python-crypto-trading-bot

作者:Stephan Avenwedde 选题:lujun9972 译者:wyxplus 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

了解在 Firefox 上运行 WebAssembly 的机会和局限性。

 title=

WebAssembly 是一种可移植的执行格式,由于它能够以近乎原生的速度在浏览器中执行应用而引起了人们的极大兴趣。WebAssembly 本质上有一些特殊的属性和局限性。但是,通过将其与其他技术结合,将出现全新的可能性,尤其是与浏览器中的游戏有关的可能性。

本文介绍了在 Firefox 上运行 WebAssembly 的概念、可能性和局限性。

沙盒

WebAssembly 有 严格的安全策略。 WebAssembly 中的程序或功能单元称为模块。每个模块实例都运行在自己的隔离内存空间中。因此,即使同一个网页加载了多个模块,它们也无法访问另一个模块的虚拟地址空间。设计上,WebAssembly 还考虑了内存安全性和控制流完整性,这使得(几乎)确定性的执行成为可能。

Web API

通过 JavaScript Web API 可以访问多种输入和输出设备。根据这个 提案,将来可以不用绕道到 JavaScript 来访问 Web API。C++ 程序员可以在 Emscripten.org 上找到有关访问 Web API 的信息。Rust 程序员可以使用 rustwasm.github.io 中写的 wasm-bindgen 库。

文件输入/输出

因为 WebAssembly 是在沙盒环境中执行的,所以当它在浏览器中执行时,它无法访问主机的文件系统。但是,Emscripten 提供了虚拟文件系统形式的解决方案。

Emscripten 使在编译时将文件预加载到内存文件系统成为可能。然后可以像在普通文件系统上一样从 WebAssembly 应用中读取这些文件。这个 教程 提供了更多信息。

持久化数据

如果你需要在客户端存储持久化数据,那么必须通过 JavaScript Web API 来完成。请参考 Mozilla 开发者网络(MDN)关于 浏览器存储限制和过期标准 的文档,了解不同方法的详细信息。

内存管理

WebAssembly 模块作为 堆栈机 在线性内存上运行。这意味着堆内存分配等概念是没有的。然而,如果你在 C++ 中使用 new 或者在 Rust 中使用 Box::new,你会期望它会进行堆内存分配。将堆内存分配请求转换成 WebAssembly 的方式在很大程度上依赖于工具链。你可以在 Frank Rehberger 关于 WebAssembly 和动态内存 的文章中找到关于不同工具链如何处理堆内存分配的详细分析。

游戏!

WebGL 结合使用时,WebAssembly 的执行速度很高,因此可以在浏览器中运行原生游戏。大型专有游戏引擎 Unity虚幻 4 展示了 WebGL 可以实现的功能。也有使用 WebAssembly 和 WebGL 接口的开源游戏引擎。这里有些例子:

有关 WebAssembly 的更多信息

WebAssembly 是一项很有前途的技术,我相信我们将来会越来越多地看到它。除了在浏览器中执行之外,WebAssembly 还可以用作可移植的执行格式。Wasmer 容器主机使你可以在各种平台上执行 WebAssembly 代码。

如果你需要更多的演示、示例和教程,请看一下这个 WebAssembly 主题集合。Mozilla 的 游戏和示例合集 并非全是 WebAssembly,但仍然值得一看。


via: https://opensource.com/article/21/3/webassembly-firefox

作者:Stephan Avenwedde 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

中断是计算机处理数据的关键部分。

中断是现代 CPU 工作方式中重要的部分。例如:当你每次在键盘上按下一个按键后,CPU 会被中断以使得 PC 读取用户键盘的输入。这个过程发生得相当快,以致于在使用体验上你不会感到任何变化或损害。

此外,键盘并不是导致中断的唯一组件。一般来说,有三种类型的事件会导致 CPU 发生中断:硬件中断、软件中断和异常。在具体介绍不同类型的中断前,我需要先定义一些术语。

定义

中断请求 interrupt request (IRQ)是由 可编程的中断控制器 programmable interrupt controlle (PIC)发起的,其目的是为了中断 CPU 和执行 中断服务程序 interrupt service routine (ISR)。中断服务程序(ISR)是一个小的程序,用来处理具体的数据,其具体的处理方式依赖于造成中断请求(IRQ)的原因。之前正在运行的进程在中断服务程序(ISR)运行结束前都会被中断。

在过去,中断请求由单独的芯片处理(中断控制器芯片 PIC),I/O 设备直接与中断控制器(PIC)相连。中断控制器(PIC)管理着多种硬件的中断请求(IRQ),并且可以直接与 CPU 通信。当一个中断请求(IRQ)产生后,中断控制器(PIC)向 CPU 写入数据,并且触发中断请求引脚(INTR)。

现如今,中断请求(IRQ)由 CPU 中的 高级可编程中断控制器 advanced programmable interrupt controller (APIC)部分来处理。每个核中都拥有属于自己的高级可编程中断控制器。

中断的类型

正如我前文中提到的,中断可以根据其来源分为三种类型。

硬件中断

当一个硬件设备想要告诉 CPU 某一需要处理的数据已经准备好后(例如:当键盘被按下或者一个数据包到了网络接口处),它将会发送一个中断请求(IRQ)来告诉 CPU 数据是可用的。接下来会调用在内核启动时设备驱动注册的对应的中断服务程序(ISR)。

软件中断

当你在播放一个视频时,音频和视频是同步播放是相当重要的,这样音乐的速度才不会变化。这是由软件中断实现的,由精确的计时器系统(称为 jiffies)重复发起的。这个计时器会使得你的音乐播放器同步。软件中断也可以被特殊的指令所调用,来读取或写入数据到硬件设备。

当系统需要实时性时(例如在工业应用中),软件中断会变得重要。你可以在 Linux 基金会的文章中找到更多相关信息:面向嵌入式开发者的实时 Linux 介绍

异常

异常 exception 是你可能之前就知道的中断类型。当 CPU 执行一些将会导致除零或缺页错误的指令时,任何其他运行中的程序都会被中断。在这种情况下,你会被一个弹窗提醒,或在控制台输出中看到** 段错误 segmentation fault 核心已转储 core dumped )**。但并不是所有异常都是由指令错误引起的。

异常可以进一步分为 错误 Fault 陷阱 Trap 终止 Abort

  • 错误:错误是系统可以纠正的异常。例如当一个进程尝试访问某个已经被换出到硬盘的页时。当请求的地址在进程的地址空间中,并且满足访问权限时,如果页不在内存(RAM)中,将会产生一个中断请求(IRQ),并开始启用缺页异常处理程序把所需的页加载到内存中。如果操作成功执行,程序将继续运行。
  • 陷阱:陷阱主要用在调试中。如果你在某个程序中设置了一个断点,你就插入了一条可以触发陷阱执行的特殊指令。陷阱可以触发上下文切换来允许你的调试器读取和展示局部变量的值。之后程序可以继续运行。陷阱同样也是运行系统调用的方式(如杀死一个进程)
  • 终止:终止是由系统表中的硬件错误或值不一致而导致的。终止不会报告造成异常的指令的所在位置。这是最严重的中断,终止将会调用系统的终止异常处理程序来结束造成异常的进程。

动手实践

中断请求按照高级可编程中断控制器(APIC)中的优先级高低排序(0是最高优先级)。前 32 个中断(0~31)是由 CPU 指定的固定序列。你可以在 OsDev 异常 页面找到关于它们的概述。随后的中断请求可以以不同的方式进行分配。 中断描述表 interrupt descriptor table (IDT)中记录了中断请求(IRQ)和中断服务程序(ISR)的对应关系。Linux 中定义了从 0 到 256 的 IRQ 向量。

为了打印出在你的系统中已注册的中断,打开一个终端并输入:

cat /proc/interrupts

你应该会看到类似如下图的结果:

 title=

内核版本为5.6.6中注册的中断 (Stephan Avenwedde, CC BY-SA 4.0)

从左到右各列的含义依次为:中断向量号、每个 CPU(0~n)中断发生次数、硬件来源、硬件源通道信息、以及造成中断请求的设备名。

在表的末尾,有一些非数字的中断。它们是特定于体系结构的中断,如 本地计时器中断 local timer interrupt (LOC)的中断请求(IRQ)号为 236。其中一些在 Linux 内核源树中的Linux IRQ 向量布局中指定。

 title=

特定于体系结构的中断 (Stephan Avenwedde, CC BY-SA 4.0)

如果要实时获取该表,请运行如下命令:

watch -n1 "cat /proc/interrupts"

总结

正确的中断请求(IRQ)处理对于硬件、驱动和软件的正常交互是必要的。幸运地是,Linux 内核很好地完成了它,一个 PC 的普通用户几乎不会注意到内核的整个中断处理过程。

中断相当复杂,本文仅仅是一个关于中断的概述。如果想要深入了解该主题可以阅读 Linux Inside 电子书(CC BY-NC-SA 4.0)和 Linux 内核教程 仓库。


via: https://opensource.com/article/20/10/linux-kernel-interrupts

作者:Stephan Avenwedde 选题:lujun9972 译者:萌新阿岩 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

了解如何处理转储文件将帮你找到应用中难以重现的 bug。

崩溃转储、内存转储、核心转储、系统转储……这些全都会产生同样的产物:一个包含了当应用崩溃时,在那个特定时刻应用的内存状态的文件。

这是一篇指导文章,你可以通过克隆示例的应用仓库来跟随学习:

git clone https://github.com/hANSIc99/core_dump_example.git

信号如何关联到转储

信号是操作系统和用户应用之间的进程间通讯。Linux 使用 POSIX 标准中定义的信号。在你的系统上,你可以在 /usr/include/bits/signum-generic.h 找到标准信号的定义。如果你想知道更多关于在你的应用程序中使用信号的信息,这有一个信息丰富的 signal 手册页。简单地说,Linux 基于预期的或意外的信号来触发进一步的活动。

当你退出一个正在运行的应用程序时,应用程序通常会收到 SIGTERM 信号。因为这种类型的退出信号是预期的,所以这个操作不会创建一个内存转储。

以下信号将导致创建一个转储文件(来源:GNU C库):

  • SIGFPE:错误的算术操作
  • SIGILL:非法指令
  • SIGSEGV:对存储的无效访问
  • SIGBUS:总线错误
  • SIGABRT:程序检测到的错误,并通过调用 abort() 来报告
  • SIGIOT:这个信号在 Fedora 上已经过时,过去在 PDP-11 上用 abort() 时触发,现在映射到 SIGABRT

创建转储文件

导航到 core_dump_example 目录,运行 make,并使用 -c1 开关执行该示例二进制:

./coredump -c1

该应用将以状态 4 退出,带有如下错误:

 title=

“Abgebrochen (Speicherabzug geschrieben) ”(LCTT 译注:这是德语,应该是因为本文作者系统是德语环境)大致翻译为“分段故障(核心转储)”。

是否创建核心转储是由运行该进程的用户的资源限制决定的。你可以用 ulimit 命令修改资源限制。

检查当前创建核心转储的设置:

ulimit -c

如果它输出 unlimited,那么它使用的是(建议的)默认值。否则,用以下方法纠正限制:

ulimit -c unlimited

要禁用创建核心转储,可以设置其大小为 0:

ulimit -c 0

这个数字指定了核心转储文件的大小,单位是块。

什么是核心转储?

内核处理核心转储的方式定义在:

/proc/sys/kernel/core_pattern

我运行的是 Fedora 31,在我的系统上,该文件包含的内容是:

/usr/lib/systemd/systemd-coredump %P %u %g %s %t %c %h

这表明核心转储被转发到 systemd-coredump 工具。在不同的 Linux 发行版中,core_pattern 的内容会有很大的不同。当使用 systemd-coredump 时,转储文件被压缩保存在 /var/lib/systemd/coredump 下。你不需要直接接触这些文件,你可以使用 coredumpctl。比如说:

coredumpctl list

会显示系统中保存的所有可用的转储文件。

使用 coredumpctl dump,你可以从最后保存的转储文件中检索信息:

[stephan@localhost core_dump_example]$ ./coredump 
Application started…

(…….)

Message: Process 4598 (coredump) of user 1000 dumped core.

Stack trace of thread 4598:
#0 0x00007f4bbaf22625 __GI_raise (libc.so.6)
#1 0x00007f4bbaf0b8d9 __GI_abort (libc.so.6)
#2 0x00007f4bbaf664af __libc_message (libc.so.6)
#3 0x00007f4bbaf6da9c malloc_printerr (libc.so.6)
#4 0x00007f4bbaf6f49c _int_free (libc.so.6)
#5 0x000000000040120e n/a (/home/stephan/Dokumente/core_dump_example/coredump)
#6 0x00000000004013b1 n/a (/home/stephan/Dokumente/core_dump_example/coredump)
#7 0x00007f4bbaf0d1a3 __libc_start_main (libc.so.6)
#8 0x000000000040113e n/a (/home/stephan/Dokumente/core_dump_example/coredump)
Refusing to dump core to tty (use shell redirection or specify — output).

这表明该进程被 SIGABRT 停止。这个视图中的堆栈跟踪不是很详细,因为它不包括函数名。然而,使用 coredumpctl debug,你可以简单地用调试器(默认为 GDB)打开转储文件。输入 bt 回溯 backtrace 的缩写)可以得到更详细的视图:

Core was generated by `./coredump -c1'.
Program terminated with signal SIGABRT, Aborted.
#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
50  return ret;
(gdb) bt
#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
#1  0x00007fc37a9aa8d9 in __GI_abort () at abort.c:79
#2  0x00007fc37aa054af in __libc_message (action=action@entry=do_abort, fmt=fmt@entry=0x7fc37ab14f4b "%s\n") at ../sysdeps/posix/libc_fatal.c:181
#3  0x00007fc37aa0ca9c in malloc_printerr (str=str@entry=0x7fc37ab130e0 "free(): invalid pointer") at malloc.c:5339
#4  0x00007fc37aa0e49c in _int_free (av=&lt;optimized out&gt;, p=&lt;optimized out&gt;, have_lock=0) at malloc.c:4173
#5  0x000000000040120e in freeSomething(void*) ()
#6  0x0000000000401401 in main ()

与后续帧相比,main()freeSomething() 的内存地址相当低。由于共享对象被映射到虚拟地址空间末尾的区域,可以认为 SIGABRT 是由共享库中的调用引起的。共享对象的内存地址在多次调用之间并不是恒定不变的,所以当你看到多次调用之间的地址不同时,完全可以认为是共享对象。

堆栈跟踪显示,后续的调用源于 malloc.c,这说明内存的(取消)分配可能出了问题。

在源代码中,(即使没有任何 C++ 知识)你也可以看到,它试图释放一个指针,而这个指针并没有被内存管理函数返回。这导致了未定义的行为,并导致了 SIGABRT

void freeSomething(void *ptr){
    free(ptr);
}
int nTmp = 5;
int *ptrNull = &nTmp;
freeSomething(ptrNull);

systemd 的这个 coredump 工具可以在 /etc/systemd/coredump.conf 中配置。可以在 /etc/systemd/systemd-tmpfiles-clean.timer 中配置轮换清理转储文件。

你可以在其手册页中找到更多关于 coredumpctl 的信息。

用调试符号编译

打开 Makefile 并注释掉第 9 行的最后一部分。现在应该是这样的:

CFLAGS =-Wall -Werror -std=c++11 -g

-g 开关使编译器能够创建调试信息。启动应用程序,这次使用 -c2 开关。

./coredump -c2

你会得到一个浮点异常。在 GDB 中打开该转储文件:

coredumpctl debug

这一次,你会直接被指向源代码中导致错误的那一行:

Reading symbols from /home/stephan/Dokumente/core_dump_example/coredump…
[New LWP 6218]
Core was generated by `./coredump -c2'.
Program terminated with signal SIGFPE, Arithmetic exception.
#0 0x0000000000401233 in zeroDivide () at main.cpp:29
29 nRes = 5 / nDivider;
(gdb)

键入 list 以获得更好的源代码概览:

(gdb) list
24      int zeroDivide(){
25          int nDivider = 5;
26          int nRes = 0;
27          while(nDivider &gt; 0){
28              nDivider--;
29              nRes = 5 / nDivider;
30          }
31          return nRes;
32      }

使用命令 info locals 从应用程序失败的时间点检索局部变量的值:

(gdb) info locals
nDivider = 0
nRes = 5

结合源码,可以看出,你遇到的是零除错误:

nRes = 5 / 0

结论

了解如何处理转储文件将帮助你找到并修复应用程序中难以重现的随机错误。而如果不是你的应用程序,将核心转储转发给开发人员将帮助她或他找到并修复问题。


via: https://opensource.com/article/20/8/linux-dump

作者:Stephan Avenwedde 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出