Crush是支持MacOS，Linux和Windows，不过感觉MacOS和Windows应该没啥必要用这个东西，当然 WSL除外

核心的功能如下：

1. 多模型支持，常见的API提供商都可以用
2. 支持会话管理，能保存、切换不同项目/话题的对话上下文
3. LSP，可以配置，能让AI更准确的理解项目中代码
4. MCP，支持stdio、http、see方式接入MCP服务

Debian/Ubuntu 安装

1
2
3
4

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://repo.charm.sh/apt/gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/charm.gpg
echo "deb [signed-by=/etc/apt/keyrings/charm.gpg] https://repo.charm.sh/apt/ * *" | sudo tee /etc/apt/sources.list.d/charm.list
sudo apt update && sudo apt install crush

装上在Terminal直接运行crush即可

Crush使用

界面挺简洁好看，我个人挺喜欢这个风格

底部状态栏，有命令提示非常贴心，第一次进需要配置模型和填写API，配置完成后也可以通过ctrl+p命令调出命令窗口并切换模型

也可以直接去下面路径的配置文件填写模型以及Key

1

$HOME/.local/share/crush/crush.json

打开文件，如下图所示

当配置好模型以及对应的API Key后，就可以直接尝试了，比如我直接说帮我创建一个c的项目，crush创建好文件夹后会列出步骤（crush会操作你的文件已经调用shell命令）

1. 创建main.c
2. 写代码
3. gcc编译

当然，创建文件或者删除文件毕竟是敏感操作，crush会弹出窗口让确认，这个建议是保留，虽然可以通过配置将这个提醒取消~

创建成功后，crush会继续执行编译，如果出错，它会分析bash打印的错误信息并进行纠正继续任务，直到完成

当实际编译成功后，crush界面也会打印程序运行的结果，并且看本地目录，实际创建了一个c_project的文件夹，里面写了mian.c的程序并编译出来可以正确运行的可执行程序，当然这个crush可以做更多的东西，以上只是一个简单的例子，大家觉的好玩的话可以自行尝试

安装Git

可以从Git官方网站下载适合操作系统的安装程序，win可以直接下载，常用的linux系统

Ubuntu

1

apt-get install git

Centos

1

yum install git

Linux平台下使用下述命令查看git版本：

1

git --version

创建本地Git仓库并配置

要在本地创建一个新的Git仓库，可以使用以下命令：

1

git init

用户信息配置

配置Git的用户信息，包括用户名和邮箱地址。在命令行中输入以下命令：

1
2

git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

–global是可选项，带上该选项在仓库目录下运行上述命令之后，可以在本机所有的仓库中生效

查看配置命令：

1

git config -l

删除对应的账户配置

1
2

git config [--global] --unset user.name
git config [--global] --unset user.email

公钥

生成 Git 的公钥是为了在使用 Git 时进行身份验证。输入以下命令来生成 SSH 密钥对：

1. 生成公钥

   1	ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

   • -t rsa：指定生成 RSA 类型的密钥。
   • -b 4096：指定密钥的位数为 4096 位，提高安全性。
   • -C "your_email@example.com"：在生成的密钥中添加注释，一般填写你的邮箱地址。
2. 系统会提示你选择保存密钥的位置，默认为 ~/.ssh/id_rsa，也可以自定义路径。
3. 然后系统会提示你设置密钥的密码（可选），设置密码可以提高密钥的安全性。
4. 生成成功后，会显示公钥的路径，默认为 ~/.ssh/id_rsa.pub。
5. 使用文本编辑器打开公钥文件 id_rsa.pub，复制里面的内容。
6. 将公钥内容粘贴到 Git 服务商（如 GitHub、GitLab）的 SSH 密钥设置中，以便进行身份验证。

生成的公钥可以用于与 Git 服务商进行安全的通信和身份验证。

将文件添加到Git仓库

将文件添加到Git仓库需要两个步骤。首先，使用以下命令将文件添加到暂存区：

1

git add filename

然后，使用以下命令将文件提交到仓库：

1

git commit -m "Commit message"

版本回退

git restore --staged <file>... 命令用于将暂存区（Staging Area）中的文件恢复到工作目录中的状态，即取消暂存的文件更改。

执行这个命令后，指定的文件将从暂存区还原到工作目录，文件的更改将不再处于暂存状态。

git reset 命令在 Git 中用于撤销更改、移动 HEAD 指针或重置暂存区。以下是 git reset 命令的常用参数和说明：

1. git reset HEAD <file>：

   • 这个命令用于将暂存区中指定文件的更改撤销，同时保留工作目录中的更改。
   • <file> 是要撤销暂存的文件名。

2. git reset --soft <commit>：

   • 这个命令将当前分支的 HEAD 指针移动到指定的提交，但保留工作目录和暂存区的更改。
   • <commit> 是要重置到的提交的引用（如 commit hash、分支名等）。

3. git reset --mixed <commit>：

   • 这个命令将当前分支的 HEAD 指针移动到指定的提交，并重置暂存区，但保留工作目录的更改。
   • <commit> 是要重置到的提交的引用。

4. git reset --hard <commit>：

   • 这个命令将当前分支的 HEAD 指针移动到指定的提交，并重置暂存区和工作目录，丢弃所有更改。
   • <commit> 是要重置到的提交的引用。

5. git reset --merge：

   • 这个命令用于解决合并冲突时，取消合并并重置到合并之前的状态。

通过合理使用 git reset 命令及其参数，可以有效地管理 Git 仓库中的提交历史和更改状态。请谨慎使用 git reset --hard 命令，因为它会永久丢弃工作目录中的更改。

假设工作区文件有 aaa，增加bbb，变成aaa bbb，之后add、commit

在工作区修改了很多文件之后，突然发现修改错了，如何恢复？

1. 手动修改
2. 使用 git checkout --filename

查看Git仓库状态

你可以使用以下命令查看Git仓库的状态：

1

git status

查看提交历史

要查看提交历史，可以使用以下命令：

1
2
3
4

git log
git log --pretty=oneline
git log --pretty=oneline --abbrev-commit
git reflog 查看每次的log 包括撤销

• --pretty=oneline选项指定了输出格式为每个提交的一行显示，显示的信息包括提交的哈希值和提交信息。这种格式适合在终端中查看提交历史，信息简洁明了。

• --abbrev-commit选项指定了显示的提交哈希值的缩写长度。默认情况下，Git会显示完整的40位哈希值，但使用--abbrev-commit选项可以缩短哈希值的长度，使得显示更加简洁。

标签管理

在 Git 中，标签（tag）是用来标记特定提交的稳定版本或重要节点的指针。以下是一些常用的 Git 标签操作：

1. 列出所有标签：

   1

   git tag

   这个命令会列出所有的标签。

2. 创建轻量标签：

   1 2	git tag <tag_name> git tag <tag_name> commit_id

   这个命令会在当前提交上创建一个轻量标签，只包含标签名。

3. 创建附注标签：

   1	git tag -a <tag_name> -m "tag message"

   这个命令会在当前提交上创建一个附注标签，可以添加标签信息。

4. 查看标签信息：

   1	git show <tag_name>

   这个命令会显示指定标签的详细信息。

5. 推送标签到远程仓库：

   1	git push origin <tag_name>

   这个命令会将指定标签推送到远程仓库。

6. 删除本地标签：

   1	git tag -d <tag_name>

   这个命令会删除指定的本地标签。

7. 删除远程标签：

   1	git push --delete origin <tag_name>

   这个命令会删除指定的远程标签。

Git 中管理标签，标记重要的提交或版本，并与团队共享稳定的版本信息。

Git分支

Git允许创建分支来并行开发不同的功能

创建分支：

1

git branch branchname

要查看本地分支，可以使用以下命令：

1. 查看所有本地分支：

   1	git branch

   这个命令会列出所有本地分支，并在当前分支前面标记一个 * 符号。

2. 查看远程分支和本地分支：

   1	git branch -a

   这个命令会列出所有本地分支和远程分支。

3. 查看本地分支的详细信息：

   1	git branch -v

   这个命令会列出所有本地分支，并显示每个分支最后一次提交的信息。

切换分支

要切换到一个不同的分支，可以使用以下命令：

1
2

git checkout branchname
git checkout -b branchname  # 创建并切换到新的分支

合并分支

完成一个功能的开发后，可以将分支合并到主分支。使用以下命令可以实现分支合并：

1

git merge branchname

删除分支

1. 删除本地分支：

   1	git branch -d <branch_name>

   或者

   1	git branch -D <branch_name>

   • -d：表示删除指定分支，如果分支的工作还未合并到当前分支，会提示错误并阻止删除。
   • -D：表示强制删除指定分支，即使分支的工作还未合并到当前分支也会删除。

2. 删除远程分支：

   1	git push origin --delete <branch_name>

   或者

   1	git push origin :<branch_name>

   这两个命令都可以用来删除远程仓库中的指定分支。

请注意，在删除分支之前，确保不再需要该分支的代码或提交记录。删除分支是一个不可逆的操作，删除后的分支及其提交记录将无法恢复。

关联分支

通过以下步骤为当前分支 dev 设置与之关联的远程分支：

1. 手动设置远程分支：

   1	git branch --set-upstream-to=origin/dev dev

   这个命令会将本地的 dev 分支与远程的 dev 分支建立关联。

2. 推送本地分支到远程：
   如果需要将本地分支 dev 推送到远程仓库，可以使用以下命令：

   1	git push -u origin dev

   这样会将本地的 dev 分支推送到远程仓库，并建立关联。

通过以上步骤，可以解决当前分支没有与之关联的远程分支的问题，并确保在推送或拉取时能够正确同步代码。

远程开发

从远程仓库克隆后，实际上 Git 会⾃动把本地的 master 分⽀和远程的 master 分⽀对应起来， 并且，远程仓库的默认名称是 origin 。在本地我们可以使⽤ git remote 命令，来查看远程库的信息

⽤ git remote -v 显⽰更详细的信息

1
2
3

tong@atong3:~/unskilled-vim$ git remote -v
origin  git@github.com:atongrun/unskilled-vim.git (fetch)
origin  git@github.com:atongrun/unskilled-vim.git (push)

克隆完成仓库之后，git branch -a 查看分支，可以在本地创建分支，通过git checkout -b dev命令，增加并且切换到dev分支

1
2
3
4
5
6

tong@atong3:~/unskilled-vim$ git branch -a
* dev
  main
  remotes/origin/HEAD -> origin/main
  remotes/origin/dev
  remotes/origin/main

将本地的 dev 分支推送到远程仓库，并将本地的 dev 分支与远程仓库的同名分支建立关联关系

1

git push --set-upstream origin dev

推送到远程仓库

如果想与团队成员代码，可以将代码推送到远程仓库。首先，添加远程仓库的地址：

1

git remote add origin remote_repository_url

然后，将代码推送到远程仓库：

1

git push -u origin master

解决Git冲突是在合并分支或拉取远程更新时可能遇到的情况。下面是解决Git冲突的一般步骤：

步骤1：检测冲突

在合并分支或拉取远程更新时，如果Git检测到冲突，会在文件中标记出冲突的部分。可以使用git status命令查看哪些文件有冲突。

步骤2：打开冲突文件

找到有冲突的文件，打开它并查看冲突的部分。冲突的部分会被标记为类似以下的格式：

1
2
3
4
5

<<<<<<< HEAD
// 本地分支的更改
=======
// 远程分支的更改
>>>>>>> branch_name

步骤3：手动解决冲突

根据冲突标记，手动编辑文件以解决冲突。需要决定保留哪些更改或如何合并这些更改。删除冲突标记并保留想要的更改。

步骤4：标记冲突已解决

在解决完冲突后，保存文件并使用以下命令标记冲突已解决：

1

git add <conflicted_file>

步骤5：完成合并

继续合并分支或拉取远程更新，并完成合并操作：

1

git commit -m "Merge conflict resolved"

步骤6：推送更改

如果是在拉取远程更新时解决冲突，完成合并后需要将更改推送到远程仓库：

1

git push

通过以上步骤，可以解决Git冲突并成功合并分支或拉取远程更新。记得在解决冲突时仔细审查更改，确保代码的完整性和正确性。

1、AIGC-API

提供高效且稳定的OpenAI聚合API，支持GPT-4 Turbo、DALL·E等OpenAI全模型和大量AI应用及框架，无论开发AI产品、训练自有模型，都能提供全面的支持。

链接：即刻注册，免费畅享$1美金测试额度！按量付费

web3

1、欧意钱包

官方介绍：LobeChat 是一个开源、高性能的聊天机器人框架。支持语音合成、多模态和可扩展插件系统。支持一键式免费部署私人ChatGPT/LLM 网络应用程序。

lobechat的github-lobe-chat🤖上有详细的文档介绍（中英文都有）并且有着discord社区，这个东西呢，就相当于部署自己的一个私人的chatgpt服务，那么重点是我为什么不直接用chatgpt而去选择部署使用lobechat呢，文档给出了下面的几个优点：

1. GPT 视觉认知
2. TTS & STT 语音会话
3. Text to Image 文生图
4. Function Calling 插件系统
5. 助手市场
6. PWA 渐进式 Web 应用
7. 移动设备适配
8. 自定义主题

对我而言，有两个地方比较吸引我，第一个是它的插件系统，有着非常丰富的插件市场，对我来说，我装了一些学术与搜索相关的插件，日常使用还是挺方便的

当然吸引我的第二个点就是有超级多的预设助手，有各个方面的，能够大大减少我们想提示词等相关的难度

我装了下边的几个助手，这个地方的塔罗占卜师的助手还挺有意思的

当然，选择这个框架还有一个原因，就是部署特别简单，用docker几行命令就OK，官方的文档非常详细（但是用三方的api服务的话还需要有注意的地方，下边细说）

lobe-chat中文文档

2 lobechat使用docker部署

LobeChat 提供了 Vercel 的 自托管版本 和 Docker 镜像，不需要任何的编程知识，就可以在几分钟部署自己的聊天机器人，这里主要说如何使用docker部署

2.1 使用官方api

使用openai的官方api的话最，只需要填写一个key值就可以，也就是将sk-xxxx替换成自己的key。OpenAI API官网中找到API keys，然后创建复制即可，然后在终端中运行如下命令

1
2
3
4
5

docker run -d -p 3210:3210 \\
  -e OPENAI_API_KEY=sk-xxxx \\
  -e ACCESS_CODE=lobe66 \\
  --name lobe-chat \\
  lobehub/lobe-chat

注意上边的命令中，ACESS_CODE和name选项都可以自定义，第一个是使用密码（使用的时候首先要输入密码），第二个是服务的名字。

2.2 使用第三方api

使用三方的API是有点坑的，有没弄好的地方就可能部署失败，我是用的AIGC-API的三方API，兼容各种主流AI，支持GPT-4 Turbo、DALL·E等OpenAI全模型和大量AI应用及框架，价格还是比较便宜的，重点是可以支付宝啥的付费，openai官方的api充值贵，而且我们充值的难度太大~

1
2
3
4
5
6

docker run -d -p 3210:3210 \\
 -e OPENAI_API_KEY=sk-xxxx \\
 -e OPENAI_PROXY_URL=https://api-proxy.com/v1 \\
 -e ACCESS_CODE=lobe66 \\
 --name lobe-chat \\
 lobehub/lobe-chat

将 https://api-proxy.com 替换成第三方的url，如果你要是用AIGC的API，需要将这个替换成：https://api.aigcapi.io，注意不要将后边的v1选项漏掉了，OPENAI_API_KEY选项就填写AIGC令牌的key值即可，然后终端运行上边的命令

如果没有替换OPENAI_PROXY_URL，会部署失败，如果漏掉v1，会出现回复异常，回复的都是空白，如下图所示

3 lobechat升级

lobechat项目还是比较火的，更新也比较多，更新的流程也是非常的简单

1. 停止并删除当前正在运行的 LobeChat 容器

1
2

docker stop lobe-chat
docker rm lobe-chat

2. 拉取 LobeChat 的最新 Docker 镜像：

1

docker pull lobehub/lobe-chat

3. 使用刚拉取的docker镜像重新部署：

1
2
3
4
5
6

docker run -d -p 3210:3210 \
  -e OPENAI_API_KEY=sk-xxxx \
  -e OPENAI_PROXY_URL=https://api-proxy.com/v1 \
  -e ACCESS_CODE=lobe66 \
  --name lobe-chat \
  lobehub/lobe-chat

1.1-预算与选择

小米14买了大概10几天了，用了这几天也简单聊聊我的使用感受，我在买手机的时候预算5k，这个价位的手机有如下几个，但是最终都没选而是选择了小米14：

• 小米14pro
• 荣耀magic6pro
• vivo x100 pro
• oppo find x7
• 苹果 15

1.2-手机权衡

当然还其实有魅族什么的，但是不大敢买，我内心最认可的两个牌子是华为和苹果，口碑、质量以及稳定性都比较好，但是好点的手机价格也相当较高，基本不是很考虑了。

内心的第二梯队就是小米、vivio、oppo和荣耀，因为我上一部手机是红米的k40 gaming，用了不到三年就硬件出现问题，去售后维修，工作人员说他们那没法修，可能是CPU问题，只能返厂，所以我对小米的品控和质量是有所怀疑的

而且小米的2000-3000挡手机用1年以上会有一定的卡顿，k40g就是一个例子，虽然整体还算ok但是无论打游戏还是日常使用，时不时的卡是家常便饭，小米的系统大家都了解，就是bug比较多~

但是为什么小米还是我心里的第二梯队了，三个原因：

• 一是因为小米的硬件性价比还是可以的；
• 二是因为这两年相机拍照做的还可以；
• 第三是因为小米的其他的杂七杂八的做的还可以，比如手环、小家电什么的

当时上边的几部手机其实挺好选择，我首先想要拍照较好，就是随手拍能出图一点，硬性要求是充电要比较快，苹果15直接被pass，而且苹果15没有高刷，当然我挺喜欢15p和15pm，不过价格太高买不起。

荣耀magic6pro我感觉硬件不错的，超长续航，最护眼的屏幕，3D人脸…，都很吸引我，但是呢荣耀这个机子的外观我实在喜欢不起来，摄像头模组我感觉甚至有些丑，而且荣耀的拍照是比其他的几家稍微差一点，并且比较关键的一点是我需要Google生态，而荣耀装Google应该不是很容易~

然后就是oppo vivo和小米14pro选择，我直接把oppo排除了，看了看视频评测，好像整体是平平无奇的，拍照似乎也没另外两家好，所以就想在vivo x100p和小米14p中选择一款

x100p优点很多，外观我喜欢，拍照水平好像也非常顶，应该是上边几个拍第一的，并且vivo的橘子系统是安卓阵营的天花板，薄纱小米澎拜，但是vivo有两个地方我非常受不了，一个是线上线下价钱不一样，好像线上讲讲价会便宜不少，我总觉的会吃亏（不会讲价），二是屏幕好像有点辣眼睛

1.3-最终选择

小米14pro呢就是别的地方都中规中矩，拍照还不错，当时我已经下单了，但是当我去店里实际体验了一下小米14pro之后，就有点想放弃了，摄像头模组太大了，拿着有点不舒服

当时我就看见旁边的小米14，拿起来感觉手感比小米14pro好多了，而且小米14的屏幕是直屏，这点真是非常的戳我，并且粉色的那一个猛男粉太爱了，相比14pro的提升（龙晶玻璃、更好一点的拍照，更快一点的快充），小米14好像已经满足我需求可，整体还便宜1000块钱

于是果断去店里拿下了小米14，小米之家送了一个耳机礼盒（耳机、笔记本、笔）和一个体重秤，线下还不错，线上应该是不会送体重秤的

2-小米14体验

2.1-外观手感

小米14的外观我是感觉还可以的（就是摄像头模组不大好看），但是摄像头模组整体比小米14Pro做的要小一些的，再加上手机小，拿在手上还是非常舒服的，很适合单手操作，估摸着姑娘们应该挺喜欢这个手机，并且小米14是直屏（贴膜比曲屏简单太多啦）

当时店里是有白色、黑色、绿色、和粉色，白色和绿色是镜面玻璃，挺粘指纹的，白色的特别好看，绿色一般吧，黑色也一般，但是材质是磨砂玻璃的不容易搞上指纹，当然最好看的和拿着最舒服的是素皮的粉色，猛男粉男的可以充一手

小米14的外观还有一个比较新颖的地方，它的手机上边没有喇叭开孔，但是这个手机依然是双扬声器

2.2-充电续航

充电速度很快90w快充，体验起来还是非常快速的，特别是冲到80左右电量极其的快，30多分钟差不多充满

但是小米14的续航也一般吧，不过也能理解，毕竟电池容量只有4610，日常轻度使用应该可以一天一充，在家的时候总是刷抖音和打游戏差不多一天要三充，甚至更多， 特别是打手游的时候耗电还是挺快的，我现在用的版本是1.31

2.3-澎湃系统

小米的澎湃系统，好像还是有一些bug的，最常见的bug是锁屏的那个时间日期显示，时不时的会倒过来，也不知道是为什么，还有就是有时候操作会顿挫一下，就像是卡了，这个情况遇到了两次，另外就是打英雄联盟手游，操作偶尔也会出现不跟手的情况，就很短暂的一瞬间

其他的一些动画上好像比miui强一些，但是整体和miui好像一模一样的，没啥特别大的区别，好像是如果米家设备多的话，交互上会比较舒服，但是我没啥设备，就不清楚具体有多好了

2.4-拍照体验

然后呢拍照好像还可以，随手拍也能有点感觉，比我之前的手机拍照已经好太多了，但是拍远处的东西的效果不是很好，可能是没有潜望镜头的原因，拍近处的东西ok的

2.5-其他优缺点

小米14最大的优点之一是装Google特别简单，小米应用商店里面就能下载Google play，我当时看到惊讶坏了，有可能小米14是装Google生态最简单的手机了~

小米14的指纹方案是用的短焦指纹，指纹解锁对准很快，对的不准，解锁速度就一般般了，但是指纹解锁有一个很讨厌的缺点，就是指纹解锁的瞬间，指纹模块的那个位置会突然亮一下，很刺眼，有设置可以在暗光的条件下关闭这个突然一亮，但是我实际测试关闭并没有什么效果

但是指纹模块也很智能，可以设置在息屏显示一个圈，方便找到指纹的位置，他这个地方最好的一点是当你没拿起手机的时候是全息屏的，当你拿起手机的时候会有这个息屏显示方便定位，可能是有什么传感器感应

3-购机总结

总的来说还可以吧，女生还是比较推荐的，而且如果想要选择小直屏，综合来看只能选择小米14了（苹果15和三星的也比小米14贵一些）

3.1-标准版本购买

小米14 徕卡镜头 光影猎人900定制影像传感器第三代骁龙8处理器1.5K OLED直屏5G智能手机 白色 16GB+512GB
———————
京东价：￥4599.00

抢购链接：https://u.jd.com/jbX0KdA

3.2-限定配色

海湾蓝是和小米汽车su7同款配色，看着到是也挺好看

小米14 徕卡光学镜头 光影猎人900 徕卡75mm浮动长焦 骁龙8Gen3 16+1T 定制色海湾蓝 小米红米手机 5G
———————
京东价：￥4999.00

抢购链接：https://u.jd.com/jqXrvNZ

以前 obsidian最让人诟病的就是表格功能，对于一个可以 all in one 的笔记软件来说，表格编辑功能还是基本纯原生的 markdown 表格的写法，基本是让人难以忍受就的。

当然 obsidian 社区插件生态很丰富，很多大神也开发了一些对应的表格增强的插件，我开始也尝试过：

• 插件1：advanced table
• 插件2：markdown table editor

对于插件1来说，只是对于原生 markdown 表格的轻微增强版，并没有真正的方便普通人编辑，我用的时候，超过3行3列的表会直接放弃用obsidian。并且obidian的表格展示效果并不友好。

在逛 obsidian 社区的时候，偶尔发现了插件2，装上之后有点惊叹，表格功能竟然能用了，如下图所示，在编写文章有插入表格需求时点击左侧边栏图标，会自动将页面分为两列，表格可以自定义几行几列，增删查改功能几乎可以方便轻度的使用

但是呢，在大表格编辑以及展示，还有部分微调，也不是很灵活，只能说可以使用，没有太好的体验，不过再这次更新之后，obsidian 的表格使用下来竟然有了 notion 表格的体验，并且编辑的表格在保存时仍按照纯文本形式的markdown保存

具体使用起来也是非常简单，在写作时，右键点击插入，再点击 Table 即可，具体如下图所示：

obsidian 的表格更新后，显示效果大大增强，编辑体验上已经类似 notion了，并且，鼠标放在表格上下左右侧，会显示出一个加号，点击即可插入行或者列。

并且另外一大改变是 obsidian 表格变成了块的形式，可以很轻易的选取整个表格，或者某行或者某列，进行拖动或者编辑，实际体验非常丝滑！

这次的 obsidian 的更新可以说完全解决了表格不好用这个最大的痛点，advanced table插件完全可以卸载，包括markdown table editor，期待obsidian越来越好！

1. 用每天记录的形式代替每天的打卡，比起打卡模式，记录没有打卡的任务压力，可以将注意力集中到活动本身，而不是完成任务上，
2. 对每天设置的小任务来说不设置上线，设置下限，我希望的是完成目标毫无负担，愿意顺着惯性继续学下去，多学一点都是额外的收获，心态完全不同，身心容易沉浸，不会顾虑什么时候才能完成任务
3. 发布社交媒体账号，可以自我push~

目前先采用这种形式吧，以后根据实际情况在修改细节部分

2023-09-14-周四

一天安排

• [x] 看一集生活大爆炸 看了两集
• [x] 两道题 边界处理细节问题
• [x] 10个单词 30
• [x] 自我拯救系列简单规划
• [ ] 仿真交叉对比 (不成功~)
• [x] 投递1~2个简历 北京 - 济南

memo

我觉得能够长期坚持一些事情有两个核心点：

一是要做适当的规划，一个比较合适的方式是将代办事项写在纸上或者记在软件上，有个著名的方法叫做GTD ， 这个方法规划任务分为五个步骤：收集、厘清、整理、检查、执行，我大概尝试了一下，并不是很适合我，这种猛地一看会有种复杂感，让对做规划和做任务清单这件事情，天然的变成了一个麻烦的任务，可能会直接导致规划与任务同时都放弃了~

为了不在规划这件事情上耗费太大经历，还是决定在obsidian上做这件事情，通过日记的形式简单做一些规划，日记的栏目只有安排和memo，安排栏只做一些简单的列表，随时添加修改，memo栏写点日常总结感想，简单并且契合日常学习工作流~

二是是坚持的事情要足够简单，很多时候总是觉得可能兴趣驱动最合适，但是兴趣驱动可能会导致规划的事情随时突破个人能力边界，一是不一定按时完成，二是可能会受挫。所以还是简单最容易坚持，定的任务足够简单，这样不仅可以轻松完成，而且时不时会超额完成~

B站关注的UP将每天多喝水作为一个任务，这个简直是不要太好，无痛完成，完成后可能还有小小的成就感~，所以呢，最近的任务规划就很简单，比如每天只背10个单词，比如看一集生活大爆炸，再比如刷两道算法题（这个可能不是很简单）~

总之呢简单才会有干劲~，今天是研三自我拯救的第一天，整体流程和方式大致确定，obsidian记录还有一个好处，如果写周记的化，可以轻松使用双链功能将每天的日记链接起来，到时候可以发布到博客平台

2023-09-15-周五

一天安排

• [x] 1集生活大爆炸
• [x] 晚上少吃点
• [x] 详细看一篇论文
• [x] 10个单词 30
• [x] 一个题 两个可能太花费时间 无法保证 先从一个做起

memo

找工作真麻烦呀，我看到996这种，连投递的欲望都没有，虽然人家公司也看不上我，我想找双休的企业，但是看了一圈应该只有外企能这样

下午的时候某家企业给我打电话，说是技术面，我接到电话，两个感觉，一是觉得懵逼和紧张，二是觉得这家企业怎么下午6点面试，这不意味着加班挺严重呀

技术面也挺快，不到10分钟吧，瞎问问就完事了，随便问的东西都不怎么知道，但是呢，还给我说，薪资和其他条件会和人事谈，可能是打算招吧

总体觉的这个面试，奇奇怪怪，不管怎么样，我是不打算去，今天细细的看了下一篇SCI，看着好像有一些写法可以借鉴，给了我一点思路，这周六周天应该能把论文搞定了~

附：今天打算的memo，打算截图，发现obsidian字体非常小，放大之后很丑，看了一下网上推荐霞鹜文楷字体，看着倒是挺舒服，就整了一下，安装非常简单，windows的cmd用scoop一键安装即可~

scoop bucket add nerd-fonts && scoop install LXGWWenKaiMono

2023-09-16-周六

一天安排

• [x] 10个单词 20
• [x] 1道题 2
• [x] 生活大爆炸1集
• [ ] 详细看一篇论文

memo

周六懒得动，简单看了点论文，日常小任务继续保持中，今天开始x不会发每日长文memo了，x不开会员不能能发超过100字属实挺麻烦，但是x对博客外链非常友好，会直接抓取显示封面图什么的，所以以后长文memo只在微博发，短文和总结周记写博客在x发布~

不过今天有个很让人高兴的事情是namesilo做活动，1美元拿下了一年的.com域名: zsjsc.com（芝士就是菜拼音首字母缩写），挺开心，com顶级域名认识的人更多一些，目前只301定向到了我的博客，也不知道干啥可能也会建站吧~

hi

常见指令

目录

1. ls/cd/pwd
2. 对文件操作
3. 查看文件内容
4. 查找
5. 打包压缩

其他一些命令

whoami/clear/rmdir/date/cal/alias/bc/uname

基础知识

目录

1. linux用户相关
2. 路径认识
3. 热键
4. 重定向
5. shell运行原理
6. 权限

ACM时间

ACM时间：stat + 文件名 查看文件状态

• Access：文件最后访问时间
• Modify：文件最后修改时间
• Change：对文件最后的Inode信息最后修改时间

今天打开阿里云盘突然提示钉钉个人内测版本推送，打开一看，好家伙，钉钉什么时候搞的这么酷了！大体一看类似于notion的页面，结合AI功能，直接有点牛波一了，如果你是笔记+AI重度用户，绝对值的一试。

我个人是有记笔记的习惯的，也尝试过很多不同的笔记软件，从最开始的typora到语雀，再到现在的obsidian，也算一个重度的markdown笔记用户了。

为什么突然会说这个钉钉个人版本呢，钉钉个人版本除了基础的各种笔记功能之外，主要还集成了AI创作服务，关键是现在是免费的（包括文生文、文生图、角色对话、以及AI创作服务）

我个人是AI的重度用户（ChatGPT、Cloude）基本天天用，目前钉钉的AI是阿里的大模型：通义千问、通义万相，分别负责文本生成和图片生成。

下面是普通文档，按空格建就能调出AI写作。下边图片的文字部分就是由钉钉AI完成。

当然钉钉这种写程序也是OK的，最左侧这一栏，第二个就是AI创作的选项，贾维斯基于通义千问，可以写文档，写代码，并且钉钉个人版本提供了很多预设的指令。

缪斯基于通义万象，就类似于midjourney，通过文本描述，它能生成对应的图片。

整体来说，AI创作功能还是挺好使的，这个钉钉呢，还有几个优点，一个是可以直接访问阿里云盘，这样在某些场景下可以说是非常方便了。另一个和notion一样，钉钉个人版呢，很贴心的准备了很多常用的模板。

比如：四象限工作中心

比如：旅游 checklist

当然呢，还有很多其他的模板，大家有兴趣可以自己尝试尝试。

还有一个网盘功能，这个就是阿里云的网盘，这个整个生态还是挺不错的，直接网盘文件+笔记

下边是内测链接，现在申请5分钟之内就能通过，感兴趣的小伙伴们可以试试，还有不少其他的功能呢。

https://workspace.dingtalk.com/welcome

Google CTemplate是一个开源的C++模板引擎，可以生成html文件，今天安装出现一些问题，在此将遇到的问题以及解决方式记录下来# 简介

安装

1. git clone https://github.com/OlafvdSpek/ctemplate.git
2. cd ctemplate
3. ./autogen.sh
4. ./configure
5. make
6. sudo make install（注意带sudo）

出现问题1

安装ctemplate出现问题 autoreconf: command not found

解决方式：
运行：sudo yum install -y autoconf automake libtool

出现问题2

编写测试程序运行遇到报错：
./mytest: error while loading shared libraries: libctemplate.so.3: cannot open shared object file: No such file or directory

解决方式：
运行：export LD\_LIBRARY\_PATH=$LD\_LIBRARY\_PATH:/usr/local/lib

cpp-httplib-v0.7.15下载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include "compile_run.hpp"
#include "../common/httplib.h"

using namespace httplib;
using namespace ns_compile_and_run;
//编译服务随时可能被多个人请求，必须保证传递上来的code，形成源文件名称的时候，要具有
////唯一性，要不然多个用户之间会互相影响
//int main()
//{
//    //提供的编译服务，打包形成一个网络服务
//    //cpp-httplib
//    // in_json: {"code": "#include...", "input": "","cpu_limit":1, "mem_limit":10240}
//    // out_json: {"status":"0", "reason":"","stdout":"","stderr":"",}
//    // 通过http 让client 给我们 上传一个json string
//    // 下面的工作，充当客户端请求的json串
//    std::string in_json;
//    Json::Value in_value;
//    //R"()", raw string
//    in_value["code"] = R"(#include<iostream>
//    int main(){
//        std::cout << "你可以看见我了" << std::endl;
//        std::cout << "第二次测试" << std::endl;
//        aaaaaaaa
//        return 0;
//    })";
//    in_value["input"] = "";
//    in_value["cpu_limit"] = 1;
//    in_value["mem_limit"] = 10240*3;
//    Json::FastWriter writer;
//    in_json = writer.write(in_value);
//    std::cout << in_json << std::endl;
//    //这个是将来给客户端返回的json串
//    std::string out_json;
//    CompileAndRun::Start(in_json, &out_json);
//    std::cout << out_json << std::endl;
//    return 0;
//}


int main(int argc, char* argv[])
{
    if(argc !=2 )
    {
        std::cerr<<"使用: "<<"\n\t"<<argv[0]<<" port"<<std::endl;
        return 1;
    }
    Server svr;

    //svr.Get("/hello", [](const Request& req, Response &resp ){
    //            resp.set_content("hello1223", "content-type: text/plain; charset=utf-8");
    //        });
    svr.Post("/compile_and_run", [](const Request& req, Response& resp){
                std::string in_json=req.body;
                std::string out_json;
                if(!in_json.empty())
                {
                    CompileAndRun::Start(in_json, &out_json);
                    resp.set_content(out_json, "application/json;charset=utf-8");
                }
            });
    svr.listen("0.0.0.0", atoi(argv[1])); // 启动http服务
    return 0;
}

postman测试请求

1
2
3
4
5
6

{
    "code": "#include <iostream>\nint main(){std::cout<<\"hello, compile\"<<std::endl;}",
    "intput": "",
    "cpu_limit": 1,
    "mem_limit": 50000
}

centos服务端

该模块为编译运行功能，该模块需要使用json库，首先安装json，作用是将结构化的数据转化为字符串，做序列化和反序列化工作

命令：sudo yum install jsoncpp-devel

整体逻辑

Start函数

1

static void Start(const std::string &in_json, std::string *out_json){}

Start函数参数

start函数的两个参数

• in_json: {“code”: “#include …”, “input”: “”, “cpu_limit”: 1, “mem_limit”:10240}
• out_json: {“status”:0, “reason”:“”, “stdout”:“”, “stderr”:“”}

in_json字符串中的内容

• code: 用户提交的代码
• input: 用户给自己提交的代码对应的输入，暂不做处理
• cpu_limit: 时间要求
• mem_limit: 空间要求

out_json字符串中的内容

• status: 状态码 （必填）
• reason: 请求结果 （必填）
• stdout: 程序运行完结果 （选填）
• stderr: 运行完的错误结果

Start函数逻辑

1. 反序列化解析in_json字符串内容
2. 根据in_json中的内容（代码、输入、限制条件）编译运行
3. 将编译运行期间的状态、结果、错误等信息序列化，通过输出型参数out_json输出

具体细节代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

static void Start(const std::string &in_json, std::string *out_json)
{
   // 解析 in_json得到 代码 输入 限制条件
   Json::Value in_value;
   Json::Reader reader;
   reader.parse(in_json, in_value);

   std::string code = in_value["code"].asString();
   std::string input = in_value["input"].asString();
   int cpu_limit = in_value["cpu_limit"].asInt();
   int mem_limit = in_value["mem_limit"].asInt();

// 根据code 生成一份文件，该文件名必须要有唯一性

   int status_code=0;
   Json::Value out_value; 
   int run_result = 0;

   std::string file_name; // code文件名

   if(code.size()==0)
   {
   status_code = -1; //代表代码为空
   goto END;
   }


   // 形成的文件名要具有唯一性，只是文件名，没有前缀路径和后缀
   file_name = FileUtil::UniqFileName();

   // 文件名有了，接下来是根据文件名，形成src源文件，并将code的内容写入到源文件中
   if(!FileUtil::WriteFile(PathUtil::Src(file_name), code))
   {
   status_code=-2; //未知错误
   goto END;
   }

   
   //形成源文件之后开始编译
   if(!Compiler::Compile(file_name))
   {
   status_code=-3; //代码编译发生错误
   goto END;
   }

   //编译完成之后运行
   run_result=Runner::Run(file_name, cpu_limit, mem_limit);
   if(run_result<0)
   {
   status_code=-2;//未知错误
   }
   else if(run_result>0)
   {
   //程序运行崩溃
   status_code=run_result;
   }
   else
   {
   status_code=0; //程序运行成功
   }
END:
   out_value["status"]=status_code;
   out_value["reason"]=CodeToDesc(status_code, file_name);

   if(status_code==0)
   {
   //整个过程全部成功
   std::string _stdout;
   FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
   out_value["stdout"]=_stdout;

   std::string _stderr;
   FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
   out_value["stderr"]=_stderr;
   }

   Json::StyledWriter writer;
   *out_json=writer.write(out_value);

   RemoveTempFile(file_name);

}

补充工具类函数

状态码解析CodeToDesc

作用：将状态码解析为对应字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

static std::string CodeToDesc(int code, const std::string& file_name)
{
std::string desc;
switch(code)
{
case 0:
desc="编译运行成功";
break;
case -1:
desc="提交的代码为空";
break;
case -2:
desc="未知错误";
break;
case -3:
//代码编译时出错
FileUtil::ReadFile(PathUtil::CompilerError(file_name), &desc, true);
break;
case SIGABRT: //6
desc="内存超过范围";
break;
case SIGXCPU: //24
desc="CPU使用超时";
break;
case SIGFPE: //8
desc="浮点数溢出";
break;
default:
desc="未知"+std::to_string(code);
break;
}
return desc;
}

形成唯一文件名UniqFileName

1
2
3
4
5
6
7
8
9
10
11
12

//形成唯一的文件名 
//通过毫秒级时间戳+原子性递增唯一值来保证唯一性
static std::string UniqFileName()
{
static std::atomic_uint id(0);
id++;

std::string ms = TimeUtil::GetTimeMs();
std::string uniq_id = std::to_string(id);
return ms+"_"+uniq_id;

}

删除临时文件RemoveTempFile

1. 判断文件是否存在
2. 若存在使用unlink函数进行删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

static void RemoveTempFile(const std::string &file_name)
{
    //清理源文件
    std::string _src = PathUtil::Src(file_name);
    if(FileUtil::IsFileExists(_src))
        unlink(_src.c_str());
    //清理编译错误文件
    std::string _compiler_error=PathUtil::CompilerError(file_name);
    if(FileUtil::IsFileExists(_compiler_error))
        unlink(_compiler_error.c_str());
    //清理可执行程序
    std::string _execute=PathUtil::Exe(file_name);
    if(FileUtil::IsFileExists(_execute))
        unlink(_execute.c_str());
    //清理输入
    std::string _stdin=PathUtil::Stdin(file_name);
    if(FileUtil::IsFileExists(_stdin))
        unlink(_stdin.c_str());
    //清理输出
    std::string _stdout=PathUtil::Stdout(file_name);
    if(FileUtil::IsFileExists(_stdout))
        unlink(_stdout.c_str());
    //清理错误
    std::string _stderr=PathUtil::Stderr(file_name);
    if(FileUtil::IsFileExists(_stderr))
        unlink(_stderr.c_str());
}

运行模块作用是：执行编译模块编译好的可执行程序，我们希望，输出、输出、错误等信息能写入到文件中。Run模块只关心运行，不关注结果的正确与否，结果正确与否靠测试用例判断

运行逻辑

这里需要重定向工作

• 标准输入
• 标准输出
• 标准错误

运行服务大致过程类似编译：

• 创建子进程
• 子进程通过execl执行编译好的可执行程序

那么这里会有两个问题

1. 编译的代码可能是死循环或者恶意代码
2. 运行出错如何知道是哪种错误

问题1可以通过资源限制来解决，通过限制运行时间，和申请内存上限等方式可以解决

问题2解决方式：
首先设计运行类，类中提供静态方法Run，该函数通过文件名可以自动拼接路径，然后再执行对应逻辑，返回值可以代表程序运行时的各种错误，比如我们规定：

• 返回值 > 0: 程序异常了，退出时收到了信号，返回值就是对应的信号编号
• 返回值 == 0: 正常运行完毕的，结果保存到了对应的临时文件中
• 返回值 < 0: 内部错误

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "../common/util.hpp"
#include "../common/log.hpp"

namespace ns_runner
{
    using namespace ns_util;
    using namespace ns_log;
    class Runner
    {
    public:
        Runner(){}
        ~Runner(){}
    public:
        static int Run(const std::string& file_name)
        {
            std::string _execute = PathUtil::Exe(file_name);
            std::string _stdin  = PathUtil::Stdin(file_name);
            std::string _stdout = PathUtil::Stdout(file_name);
            std::string _stderr = PathUtil::Stderr(file_name);
            umask(0);
            int _stdin_fd = open(_stdin.c_str(), O_CREAT|O_RDONLY, 0644);
            int _stdout_fd = open(_stdout.c_str(), O_CREAT|O_WRONLY, 0644);
            int _stderr_fd = open(_stderr.c_str(), O_CREAT|O_WRONLY, 0644);

            if(_stdin_fd <0 || _stdout_fd<0 || _stderr_fd<0)
            {
                LOG(ERROR)<<"运行时打开文件失败"<<"\n";
                return -1; //-1 代表打开文件失败
            }

            pid_t pid = fork();
            
            if(pid<0)
            {
               LOG(ERROR)<<"运行时创建子进程失败"<<"\n";
               close(_stdin_fd);
               close(_stdout_fd);
               close(_stderr_fd);

               return -2; //-2 代表创建子进程失败
            }
            else if(pid==0)
            {
                // 子进程，先进行重定向，再程序替换
                dup2(_stdin_fd, 0);
                dup2(_stdout_fd,1);
                dup2(_stderr_fd, 2);

                execl(_execute.c_str(), _execute.c_str(), nullptr);
                exit(1);
            }
            else
            {
                // 父进程
                // 先关闭文件描述符
                
                close(_stdin_fd);
                close(_stdout_fd);
                close(_stderr_fd);
                
                int status=0;
                waitpid(pid, &status, 0);
                LOG(INFO)<<"运行完毕 Info: "<<(status & 0x7F)<<"\n";
                return status & 0x7F;
            }
        }
    };
}

资源限制

具体资源限制，我们使用linux系统的系统调用setrlimit函数

setrlimit

setrlimit是一个用于设置进程资源限制的函数，它的原型如下：

1
2
3

#include <sys/resource.h>

int setrlimit(int resource, const struct rlimit *rlim);

其中，第一个参数resource指定了要设置的资源类型，它可以取以下值之一：

• RLIMIT_CORE：设置core文件的最大大小（以字节为单位）；
• RLIMIT_CPU：设置CPU时间的最大值（以秒为单位）；
• RLIMIT_DATA：设置数据段的最大大小（以字节为单位）；
• RLIMIT_FSIZE：设置可创建文件的最大大小（以字节为单位）；
• RLIMIT_NOFILE：设置进程可以打开的最大文件数；
• RLIMIT_STACK：设置进程堆栈的最大大小（以字节为单位）；
• RLIMIT_AS：设置进程地址空间的最大大小（以字节为单位）；
• RLIMIT_NPROC：设置用户可以拥有的最大进程数；
• RLIMIT_RSS：设置进程驻留集大小的最大值（以字节为单位）；
• RLIMIT_MEMLOCK：设置进程能够锁定在内存中的最大字节数；
• RLIMIT_NICE：设置进程的nice值的最大值。

第二个参数rlim是一个指向rlimit结构体的指针，该结构体定义如下：

1
2
3
4

struct rlimit {
    rlim_t rlim_cur; // 资源限制的当前值
    rlim_t rlim_max; // 资源限制的最大值
};

rlim_t类型的rlim_max成员可以被赋值为以下宏：

• RLIM_INFINITY：表示无限制，将rlim_max设置为此宏将取消对资源的任何限制；
• RLIM_SAVED_MAX：表示使用之前保存的最大值，最初由系统管理员设置；
• RLIM_SAVED_CUR：表示使用之前保存的当前值，最初由系统管理员设置；
• 其他正整数：表示将rlim_max设置为指定的正整数值，表示资源的最大限制。需要注意的是，此值必须小于或等于系统的最大限制值，并且通常应该小于或等于当前进程的软限制值。

需要注意的是，不同的资源类型可能会有不同的最大限制值。例如，对于RLIMIT_NOFILE（最大打开文件数），通常的最大限制值是系统的最大文件描述符数。对于RLIMIT_CPU（CPU时间限制），通常的最大限制值是LONG_MAX（通常为2147483647）。

使用setrlimit函数可以为进程设置指定资源的限制，比如限制进程可以打开的最大文件数、限制进程的CPU时间等。调用该函数前，需要先定义并初始化一个rlimit结构体，然后将其作为参数传递给setrlimit函数。

例如，以下代码将限制进程可以打开的最大文件数为1000：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <sys/resource.h>
#include <stdio.h>

int main() {
    struct rlimit limit;

    limit.rlim_cur = 1000;
    limit.rlim_max = 1000;

    if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
        perror("setrlimit");
        return 1;
    }

    printf("限制进程可以打开的最大文件数为：%lld\n", (long long) limit.rlim_cur);

    return 0;
}

setrlimit函数只能将资源限制设置为小于或等于系统默认值或进程当前限制值的值。如果试图将资源限制设置为大于这些值的值，setrlimit函数将失败并返回-1。在这种情况下，可以考虑使用sysctl函数调整系统级别的资源限制。同时，需要注意，setrlimit函数只能影响当前进程以及其子进程的资源限制，无法影响其他进程。

资源限制测试

整体测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <iostream>
#include <sys/resource.h>
#include <unistd.h>
#include <signal.h>

void handler(int signo)
{
    std::cout<<"signo: "<<signo<<std::endl;
}
int main()
{
    for(int i=1; i<=31; i++)
    {
        signal(i, handler);
    }

    //测试死循环时间超时
    //struct rlimit r;
    //r.rlim_cur = 1; //设置1秒限制
    //r.rlim_max = RLIM_INFINITY;

    //setrlimit(RLIMIT_CPU, &r);

    //while(1){}
    
    //测试申请内存
    struct rlimit r;
    r.rlim_cur = 1024*1024*40;
    r.rlim_max = RLIM_INFINITY;

    setrlimit(RLIMIT_AS, &r);
    int count=0;
    while(true)
    {
        int *p = new int[1024*1024];
        count++;
        std::cout<<"count: "<<count<<std::endl;
        sleep(1);
    }
    return 0;
}

1、死循环时间限制测试

收到24号信号 SIGXCPU

2、申请虚拟空间大小限制

运行模块加入资源限制

• cpu_limit: 该程序运行的时候，可以使用的最大cpu资源上限
• mem_limit: 改程序运行的时候，可以使用的最大的内存大小(KB)

setProcLimit函数

对资源做时间、空间限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 在运行之间需要对资源做一些限制
        // 包括 时间、空间
        static void setProcLimit(int _cpu_limit, int _mem_limit)
        {
            // 设置CPU的时长
            struct rlimit cpu_rlimit;
            cpu_rlimit.rlim_cur = _cpu_limit;
            cpu_rlimit.rlim_max = RLIM_INFINITY;

            setrlimit(RLIMIT_CPU, &cpu_rlimit);
            
            // 设置限制内存
            struct rlimit mem_rlimit;
            //转成kb
            mem_rlimit.rlim_cur = _mem_limit*1024;
            mem_rlimit.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_AS, &mem_rlimit);
        }

Run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

static int Run(const std::string& file_name, int cpu_rlimit, int mem_rlimit)
{
    std::string _execute = PathUtil::Exe(file_name);
    std::string _stdin  = PathUtil::Stdin(file_name);
    std::string _stdout = PathUtil::Stdout(file_name);
    std::string _stderr = PathUtil::Stderr(file_name);
    umask(0);
    int _stdin_fd = open(_stdin.c_str(), O_CREAT|O_RDONLY, 0644);
    int _stdout_fd = open(_stdout.c_str(), O_CREAT|O_WRONLY, 0644);
    int _stderr_fd = open(_stderr.c_str(), O_CREAT|O_WRONLY, 0644);

    if(_stdin_fd <0 || _stdout_fd<0 || _stderr_fd<0)
    {
        LOG(ERROR)<<"运行时打开文件失败"<<"\n";
        return -1; //-1 代表打开文件失败
    }

    pid_t pid = fork();
    
    if(pid<0)
    {
        LOG(ERROR)<<"运行时创建子进程失败"<<"\n";
        close(_stdin_fd);
        close(_stdout_fd);
        close(_stderr_fd);

        return -2; //-2 代表创建子进程失败
    }
    else if(pid==0)
    {
        // 子进程，先进行重定向，再程序替换
        dup2(_stdin_fd, 0);
        dup2(_stdout_fd,1);
        dup2(_stderr_fd, 2);
        
        setProcLimit(cpu_rlimit, mem_rlimit);
        execl(_execute.c_str(), _execute.c_str(), nullptr);
        exit(1);
    }
    else
    {
        // 父进程
        // 先关闭文件描述符
        
        close(_stdin_fd);
        close(_stdout_fd);
        close(_stderr_fd);
        
        int status=0;
        waitpid(pid, &status, 0);
        LOG(INFO)<<"运行完毕 Info: "<<(status & 0x7F)<<"\n";
        return status & 0x7F;
    }
}

问题以及记录

遇到问题

提问：centos，我一个c++程序，先创建子进程，然后在子进程用setrlimit函数限制程序运行时间，再用execl执行另一个a.out程序，但是父进程waitpid收到11号信号，如果不加setrlimit限制，就正常运行，这是怎么回事呢？

具体原因

AI回复：从描述来看，你遇到的问题可能与 setrlimit 函数设置的资源限制有关。11号信号是 SIGSEGV，即段错误。这个信号通常由于进程试图访问其虚拟地址空间中无法访问的内存区域而引发，例如非法指针解引用、栈溢出等。

在这种情况下，可能的原因是你使用 setrlimit 设置了过于严格的资源限制。这可能导致子进程在运行时无法分配足够的资源（例如内存），从而触发 SIGSEGV 信号。

要解决这个问题，你可以尝试以下步骤：

1. 仔细检查 setrlimit 函数设置的资源限制，确保它们不会导致子进程无法正常运行。例如，如果你设置的是 RLIMIT_CPU，确保所设置的时间限制允许子进程有足够的时间运行。

2. 在子进程中添加错误处理和调试信息，以便在出现问题时更容易识别问题所在。你可以使用 try 和 catch 语句捕获异常，并在控制台上输出有关错误的详细信息。

3. 如果仍然无法解决问题，可以考虑在父进程中使用 ptrace 函数来监控子进程的系统调用和信号。这样可以帮助你更详细地了解子进程中发生了什么。

二、具体实现

首先是编译模块，封装Compiler类，提供Compile函数接口，具体编译流程如下：

1. 根据传入文件名，对其进行编译，这里需要实现一个工具类
2. 工具类，对文件名进行拼接，待编译的文件放在compile_server/temp文件下，例如test.cpp
3. 拼接目标有源文件拼接：test->./temp/test.cpp
4. 可执行程序拼接：test->./temp/test.exe
5. 错误信息文件拼接：test->./temp/test.stderr
6. 正式逻辑开始，首先创建子进程，子进程进行编译服务
7. 通过程序替换：execlp函数，执行g++编译源文件，生成text.exe
8. g++编译可能成功，可能失败，如果失败，会通过stderr打印，这里对stderr进行重定向到指定文件(dup2函数)：./temp/test.stderr
9. 父进程对子进程编译结果进行判断，这里只需要判断./temp/test.exe函数是否存在，存在就是编译成功
10. 在工具类中FileUtil类提供接口IsFileExists判断文件是否存在，其中调用stat函数

1、compiler.hpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#pragma once

#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>


#include "../common/util.hpp"
#include "../common/log.hpp"

//只提供编译服务
namespace ns_compiler
{
    //引入路径拼接功能
    using namespace ns_util;
    using namespace ns_log;
    class Compiler
    {
    public:
        Compiler(){};
        ~Compiler(){}

        static bool Compile(const std::string& file_name)
        {
           pid_t pid = fork(); 
           if(pid<0)
           {
                LOG(ERROR)<<"内部错误,创建子进程失败"<<"\n";
                return false;
           }
           else if(pid == 0)
           {
                //子进程
                umask(0);
                int _stderr = open(PathUtil::Stderr(file_name).c_str(), O_CREAT | O_WRONLY, 0644); //110 100 100
                if(_stderr<0)
                {
                    LOG(WARNING)<<"没有成功形成stderr文件"<<"\n";
                    exit(1);
                }
                dup2(_stderr, 2);
                execlp("g++","g++", "-o", PathUtil::Exe(file_name).c_str(),PathUtil::Src(file_name).c_str(),"-std=c++11", NULL);
               // 执行完成后，这里判断有没有形成.exe的可执行程序，如果形成，说明编译成功
               // 如果没有形成，需要将错误信息重定向到文件中
                LOG(ERROR)<<"g++编译失败，可能是参数错误"<<"\n";
                exit(1);    
           }
           else
           {
                waitpid(pid, nullptr,0);
                if(FileUtil::IsFileExists(PathUtil::Exe(file_name).c_str()))
                {
                    LOG(INFO)<<PathUtil::Src(file_name)<<"编译成功"<<"\n";
                    return true;
                }
                LOG(ERROR)<<"编译失败，没有形成可执行程序"<<"\n";
                return false;
           }
        }
    };
}

2、util.hpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/time.h>

namespace ns_util
{
    class TimeUtil
    {
    public:
        static std::string GetTimeStamp()
        {
            struct timeval _time;
            gettimeofday(&_time, nullptr);
            return std::to_string(_time.tv_sec);
        }
    };

    const std::string temp_path = "./temp/";
    
    class PathUtil
    {
    public:
        static std::string AddSuffix(const std::string& file_name, const std::string& suffix)
        {
            std::string path_name = temp_path+file_name;
            path_name+=suffix;
            return path_name;
        }
        // 构建源文件路径+后缀的完整文件名
        // ./temp/1234.cpp
        static std::string Src(const std::string& file_name)
        {
            return AddSuffix(file_name, ".cpp");
        }
        
        //构建可执行程序的完整路径+后缀名
        //1234->./temp/1234.exe
        static std::string Exe(const std::string& file_name)
        {
            return AddSuffix(file_name, ".exe");
        }

        //构建该程序对应的标准错误的完整路径+后缀名
        //1234->./temp/1234.stderr
        static std::string Stderr(const std::string& file_name)
        {
            return AddSuffix(file_name, ".stderr");
        }
    };

    class FileUtil
    {
    public:
        static bool IsFileExists(const std::string& file_name)
        {
            struct stat buf;
            if(stat(file_name.c_str(), &buf)==0)
            {
                return true;
            }
            return false;
        }
    };


}

3、log.hpp

为了更方便调试和打印信息，封装一个日志函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#pragma once
#include <iostream>
#include <string>
#include "util.hpp"

namespace ns_log
{
    using namespace ns_util;

    enum{
        INFO,
        DEBUG,
        WARNING,
        ERROR,
        FATAL
    };

    inline std::ostream& Log(const std::string& level, const std::string& file_name, int line)
    {
        //日志等级
        std::string message = "[";
        message+=level;
        message+="]";
        //报错文件名
        message+="[";
        message+=file_name;
        message+="]";

        //报错行数
        message+="[";
        message+=std::to_string(line);
        message+="]";

        //报错时间戳
        message+="[";
        message+=TimeUtil::GetTimeStamp();
        message+="]";

        std::cout<<message;
        return std::cout;
    }

    #define LOG(level) Log(#level, __FILE__, __LINE__)
}

所用技术:

除了ctemplate可能会稍微写点之外，其余所有关于前端渲染相关内容不做说明~~~

• C++ STL 标准库
• Boost 准标准库(字符串切割)
• cpp-httplib 第三方开源网络库
• ctemplate 第三方开源前端网页渲染库
• jsoncpp 第三方开源序列化、反序列化库
• 负载均衡设计
• 多进程、多线程
• MySQL C connect
• Ace前端在线编辑器（使用现成…）
• html/css/js/jquery/ajax （使用现成…）

开发环境：

• centos7
• vim
• mysql workbench

2、项目宏观结构

项目由3个核心模块组成

1. common: 公众模块
2. compile_server:编译运行模块
3. oj_server: 获取题目列表，查看编写题目界面，负载均衡，其他功能

leetcode结构

只实现类似leetcode的题目列表+在线编程功能

项目宏观结构

编写思路

1. 先编写 compile_server
2. oj_server
3. version1 基于文件版的在线OJ
4. 前端的页面设计
5. version2 基于 MySQL 版的在线OJ

GPT-4（Generative Pre-trained Transformer 4）是OpenAI推出的一款具有革命性影响的大型语言模型。基于Transformer架构，GPT-4的设计使其在理解和生成自然语言文本方面表现出色，让机器与人类的沟通变得更为流畅。该模型通过在大量文本数据上进行预训练，学会了诸多领域的知识，包括科技、文学、历史等。此外，GPT-4具备强大的迁移学习能力，可以在微调阶段适应各种具体任务，如问答、摘要、翻译等。

1、Poe

Poe每天免费一次试用GPT4，并且可以访问 ChatGPT、Claude instant、Claude+、等，强烈推荐！

网址：https://poe.com/GPT-4

体验：✨✨✨✨✨

2、Ora

每天5条GPT4信息，并且可以创建并训练不同的机器人

网址：https://ora.sh/openai/gpt4

体验：✨✨✨✨

3、Forefront Chat

看下图，有好多角色可以自定义，比较推荐

网址：https://chat.forefront.ai

体验：✨✨✨✨

4、ChatMind AI

每天免费1次

网址：https://chatmindai.cn

体验：✨✨

GPT-4的强大不仅体现在它可以处理多种任务，还表现在它能够理解和生成各种语言和方言。这使得GPT-4具有极高的普适性，GPT-4在多个任务中展示了惊人的性能，有时甚至超越了人类专家。

大家快用起来！！！！

太极、两仪、四象和八卦是中国古代哲学和道家思想的重要概念，它们相互关联，共同构成了一个完整的哲学体系。对于上边的几个名词基本每个人都听过，但是让大家说说是哪八个卦，每个卦象是什么样的，能说出来的人应该不多。这里就带大家认识一下，争取最快的速度让大家记住

目标

• 八卦-卦象（最快认识、最低目标是会画）
• 八卦-卦序 （简单了解）

太极

太极是道家哲学中的核心概念，代表了宇宙万物生成和变化的根本原因。太极即无极，无极生太极，太极生两仪。它既包含了宇宙的一切，也是宇宙的起源。太极图象往往用一副黑白相间的圆形图案表示，代表阴阳两极的和谐统一。

两仪

两仪指的是阴和阳，分别代表宇宙中的负面和正面力量。阴阳是相互依存、对立统一的，它们共同促成了宇宙的生成和变化。两仪生四象，即阴阳进一步演化所产生的四种状态。

四象

四象是指：太阴、少阴、太阳、少阳。它们代表了阴阳两仪在宇宙中的进一步演化和辩证过程，太阴和少阳形成一对，太阳和少阴形成另一对。四象生成八卦，是由阴阳两仪演化后的八种状态。

八卦

八卦是古代中国的一种卜辞和预测体系，它包括八个基本符号，分别是：乾、兑、离、震、巽、坎、艮、坤。每个卦由三个爻组成，爻分为阳爻（—）和阴爻（–）两种。八卦的组合和变化可以表示宇宙万物运动变化的规律。

八卦可以用来进行预测，这是因为它反映了宇宙中阴阳两仪的变化规律。根据阴阳的变化，可以对未来的事物发展进行推测。这种预测哲学体现了古代中国人对宇宙规律的探索和理解。

先天八卦和后天八卦是八卦的两种排列顺序。

先天八卦：又称伏羲八卦，是传说中伏羲创立的八卦顺序。先天八卦的排列顺序是：乾、兑、离、震、巽、坎、艮、坤。先天八卦强调八卦的生成顺序，体现了宇宙生成和事物发展的过程。

后天八卦：又称文王八卦、周易八卦，是传说中周文王创立的八卦顺序。后天八卦的排列顺序是：乾、坎、艮、震、巽、离、兑、坤。后天八卦强调八卦之间的相互关系，体现了事物发展的规律和道家的阴阳哲学。

总之，太极、两仪、四象和八卦是古代中国哲学和道家思想的重要组成部分，它们共同揭示了宇宙万物生成和变化的奥秘。先天八卦和后天八卦则是八卦的两种排列顺序，分别强调八卦的生成顺序和相互关系，体现了古代中国人对宇宙规律的探索和理解。

当然有，这个解决方法就是AutoGPT，这个核心是我们只需要提出我们想要完成的任务，其他的一切交给AI自己来，让AI自己给自己设定阶段性任务，自己给自己提示，只在必要的时候给他纠正即可，其他时候我们只用等代结果，听起来是不是很爽？

其实上边说的还是太过抽象了一点，我们还是详细举个具体的例子，比如我想让GPT写个论文，我们大概有几种种方式：

• 直接给GPT主题或题目让它自由发挥
• 给GPT限定范围，并且给GPT一个具体身份
• 让GPT写大纲，让后根据大纲再让GPT写
• …

或者对其进行排列组合，但是一般来说，只有我们要求的越多，给GPT限制越多，最后的结果质量才好，但是有了AutoGPT之后会变成什么样呢？我们只需要告诉GPT我们要写的题目或者主题，它会不断的拆分任务，然后自己完成自己提出的任务，相当于让ChatGPT自己指挥自己，把我们之前不断和GPT交互的过程给省略掉。

1、AutoTravel

这个是我觉得最有意思得项目了，对于旅游，做攻略，做决定对很多小伙伴来说是一件非常不容易的，现在好了，有人基于AutoGPT做了这个AutoTravel，只要我们给它提出任务，它就可以自动给我们做出攻略！

项目地址：https://auto-travel-gpt4.vercel.app/

2、DOGPT

国内也可以用，完全免费，大家可以轻点薅羊毛，大佬还贴心的做了一些分类

项目地址：https://www.dogpt.ai/

3、AutoGPT（程序员版）

这个是github上非常火的一个项目，117k的恐怖star数，不过需要配置呀，稍微有点麻烦，但是还好，有教程，下边贴了鱼皮大佬的教程

项目地址：https://github.com/atongrun/Auto-GPT

如何用？这里大佬鱼皮写了详细的教程并且录制了视频，根据鱼皮的教程很快就能将项目配置好。

(14 条消息) 程序员鱼皮 - 知乎 (zhihu.com)

4、cognosys

这个可以直接用不用配置

项目地址：https://app.cognosys.ai/create

了解更多信息可以关注公众号：芝士就是菜

科研工作专用ChatGPT拓展，特别优化学术Paper润色体验，支持自定义快捷按钮，支持自定义函数插件，支持markdown代码块表格显示，Tex公式双显示，新增Python/C++项目剖析/自译解功能，PDF/LaTex论文翻译/总结功能，兼容ChatGLM等本地模型

项目地址

项目功能

VSCode+Anaconda配置

一、git clone项目到本地

1、使用Git

本地新建一个文件夹，然后打开git工具直接clone下来就OK

2、直接下载

二、配置一下APIKEY和代理

这里需要openai 的 apikey以及科学上网的方式，原文档讲述的非常全面

教程：项目中纯新手教程

三、Vscode配置环境

1、打开anaconda prompt

执行下述命令

1）conda create -n gptac_venv python=3.11
2）conda activate gptac_venv
3）python -m pip install -r requirements.txt

备注：使用官方pip源或者阿里pip源，其他pip源（如一些大学的pip）有可能出问题，临时换源方法：

python -m pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/

2、打开vscode

1、ctrl + shift +p 打开设置

2、搜索python编译

3、选择建好的conda环境

4、ctrl + ~ 调出来终端，输入 python main.py

四、大功告成

现在就可以愉快的使用了

这里面的几个功能都挺不错的，英文学术润色、中文学术润色、中英互译、查找语法错误，都挺好

PS： 以前的ChatGPT账号调用API是送18刀的免费额度的，但是这个免费的额度在4月1号就过期了，所以如果你的账号是以前注册的，有可能会显示额度不够的情况，这时候有两种解决方法。

• 向原账户充钱，这个也挺麻烦的
• 创建个新的账号（推荐），这个成本最低，新创建的账号，送5刀的额度，其实就很多了，可以让我们用很久了。

1、ChatBox

A desktop app for ChatGPT API (OpenAI API) that supports Windows, Mac & Linux. 开源的ChatGPT桌面应用，下载安装包直接运行，prompt 开发神器，Window、Mac、Linux全平台支持。（需要API key和科学上网）

网址：https://github.com/Bin-Huang/chatbox

2、ChatPDF

ChatPDF是一种人工智能工具，可以为您的PDF文件提供交互功能，让您可以像与他人交流一样与PDF文件进行交互。使用ChatPDF可以帮助您检索、搜索和总结PDF文件中的相关内容，使用户能够在更短的时间内了解重要信息。您可以通过单击此链接来访问它。（太大的还有特别多页的PDF需要付费）

网址：https://www.chatpdf.com/

3、Portal

Portal是一款跨平台工具，旨在将ChatGPT的能力整合到用户的工作流程中。具体来说，他可以将任何选择的文本通过快捷键发送到ChatGPT，进行处理，然后返回到用户的剪切板，或者在光标处返回（实现打字机效果）。这意味着你可以在大部分没有接入ChatGPT能力的应用立即获得ChatGPT的加持。（需要API key和科学上网）

网址：https://github.com/lxfater/Portal

4、Obsidian笔记ChatGPT插件

将ChatGPT（几乎）无缝集成到Obsidian中，重度Obsidian用户和重度ChatGPT用户的福音（需要API key和科学上网）

网址：https://github.com/bramses/chatgpt-md

二、ChatGPT镜像（魔法版+正常版）

继续更新一些ChatGPT的镜像站啊，以下大多数都有上下文记忆功能，大部分都是免费的或者一天有一些免费的次数，其中有几个网址有免费几次的GPT-4的试用，以下网址，希望大家且用且珍惜，如果有做的不错的网址，又有赞赏的功能的话，希望大家给大佬们打赏个水钱，毕竟你的每一次请求，大佬那边都是有成本的（OpenAI的api key免费的token只有18美金）

1、正常使用

以下网址，国内可以使用，无需魔法、无需账号，总共有5个

https://ai.bo-e.com/
https://chat.pypig.com/
https://chat.huashuyunai.com/?code=0613KCGa1u451F0d4IGa1RdEIQ13KCGv&state=34d026f4ca7ff889d404fd78fde31ef2#/
https://ai.chatmsgz.com/h5/10001/#/pages/chat/chat/index

2、需要魔法

针对没有账号或者被封的用户但是你会科学的上网，下边的大部分都挺不错，可以都试一试，比较推荐的网站有11个，一般推荐的网站有5个

比较推荐

https://poe.com/
https://theb.ai/
https://chat.yqcloud.top/
https://chat.moyunav.com/
https://94gpt.com/
https://gpt.xeasy.me/
https://gpt.tool00.com/
https://trychatgp.com/
https://ai117.com/
https://chatcat.pages.dev/
https://freegpt.one/

一般推荐

https://chat.51buygpt.com/
https://chat.geekr.dev/
https://desk.im
https://ai.ls/
https://chatforai.com/

3、强烈推荐

Defalsh 是全球首个以 GPT 为信息处理引擎的 Web3 内容聚合平台，使用以太坊地址登录，免费体验依然保留，chat-next-web部署的gpt网页版，做的区块链项目，现在完全免费哦！加入它的 Discord 创世社区 - 限量领取 OG 身份

网址：https://www.deflash.ai/