x265中satd函数的向量指令实现

摘要

上一篇文章中已经讲述了satd的向量原理,这里将主要讲述satd的向量指令实现方法,会涉及到具体的指令已经实现过程中需要注意的内容,但还是比较粗略的讲述。因为本人毕设就是对x265在MIPS和loongson架构上实现向量指令优化,因此这里会涉及两个架构,将分别进行讲述。

正文

x86

对于x86的向量指令我一直使用的是这个网站进行查询
https://www.officedaytime.com/simd512e/simd.html?mf=4&mt=4&mc=0
简单文字解释+图表,简单明了。

进入正文
satd的传入参数为
(const pixel* pix1, intptr_t stride_pix1, const pixel* pix2, intptr_t stride_pix2)
首先使用movq指令加载pix1和pix2的内容(32b),置于128位向量寄存器xmm的低32位中。

所有数加载完毕后,使用shufps混洗指令,完成第一二行、三四行内容的复制以及合并。得到
{ r o w 1 , r o w 1 , r o w 0 , r o w 0 } \{row_1, row_1, row_0, row_0\} {row1,row1,row0,row0}
{ r o w 3 , r o w 3 , r o w 2 , r o w 2 } \{row_3, row_3, row_2, row_2\} {row3,row3,row2,row2}

之前有设置一个常数向量
{-1,1,-1,1,1,1,1,1,-1,1,-1,1,1,1,1,1}
这里使用pmaddubsw指令将上述复制合并结果与常数向量对应位置相乘、相邻位置求和并扩展。

这条指令需要特别注意,它有目的寄存器和源寄存器。目的寄存器是无符号表示,源寄存器是有符号表示。该指令的实现方法是先扩展再计算。因此两个寄存器使用不同的扩展方法得到16位数,然后再进行有符号计算。该形式也就契合了pixel无符号类型和有符号常数。

而从总的来看,整个算法是先实现列变换、再实现行变换,而这条指令却是行变换的一部分。算法这样设置必定是有原因的。最初是8位无符号数pixel,在有符号计算过程中必定需要更高位的表示,因此这里必定需要位数的扩展。算法便将扩展与行变换的一部分同时执行,基于行列变换相互之间不会造成影响的原理,而且扩展到16位已经为加减运算保留了足够的空间。

然后使用psubw将pix1和pix2对应位置相减得到残差数据。

从这里开始,执行列变换。其实列变换就是通过行之间的加减操作完成。这里用到paddwpsubw完成对应位置的加减,还会使用punpcklqdqpunpckhqdq指令将寄存器中的64位交错一下。

示意图

再使用paddwpsubw完成对应位置加减,完成列变换。具体的数据都在上一篇文章中表示,这里就不再重复写了,可能需要两个文章交换着看,造成的不便还请谅解。

开始进行行变换,行变换需要对同一个寄存器中不同元素(16b)进行加减操作。因此这里需要将寄存器中的数据交错一下,构造一个原本相邻的元素,当前处于两个寄存器的对应位置。

这里首先使用pblendw常数选择指令设置170(10101010)的常数,交错存储两个寄存器中的元素。再使用对32位元素移位指令pslldpsrld分别处理两个寄存器,在使用por逻辑或指令合并两个处理后的寄存器。最终得到这样一个效果。

示意图

然后使用取绝对值指令pabsw获取绝对值。使用pmaxsw指令得到两个寄存器对应位置的较大值。这里使用了一个向量常数,16位的元素,全1。pmaddwd相乘求和指令,与全1常数向量配合,完成寄存器相邻元素的求和以及扩展,得到32位元素。由于结果是int类型(32b),因此后续不能再使用madd这种带扩展的指令。算法则是使用pshufdpshuflw混洗指令将原本相邻的元素置于纵向对应位置,然后使用paddd求和,得到最终结果。

上述就是对x86向量实现satd_4x4的描述。其实后续还有satd8和sa8d的内容。大致思想是相同的,但实现的细节存在差异,而且还需要考虑一些硬件因素。

MIPS

需要使用MIPS的向量指令集重建该算法。MIPS和x86的向量指令风格还是非常不同的,各自具有各自的优势,因此就需要调整算法,附和MIPS的特点。当前使用的是MSA1.0的向量指令集以及loongson自定义的128位指令集。下面对两者的差异进行描述。

这里带过一下,MIPS体系结构中有32个向量寄存器,x86只有16个。因此在项目中,变量的数量限制相对较为宽松,不需要像x86那样,时常需要movdqa向量赋值指令,去协调向量寄存器的使用数量。该操作会引入指令间的相关,影响性能。

进入正文
首先使用lsx的vblw指令加载一行pixel(32b)到128向量寄存器的低32位中。后续就产生了一些变化,这里也引入了一些问题,下面详细讲。

在x86中,这里是复制合并,然后与常量madd。针对madd msa1.0中也有同类型指令dotp点乘指令。但问题就出在这里,dotp只支持同为有符号或者无符号的操作。msa2.0这里不讨论。而使用有符号操作时dotp_s.h,pixel(8位)的表示也就出现问题。把无符号数当做有符号数扩展。pixel值小于128时,还真是对的。但大于128时就出现错误,这也是在测试中偶然发现的。由于指令的限制,导致这一计算方法无效。

这里也引出一个问题,针对位数,这在计算过程中是始终需要考虑的,有符号和无符号相对还好,只是在乘除时需要考虑。这里必须完备的考虑计算过程中数据的上下限,比如pixel(0 ~ 255)。但同时位数的加宽也会导致数据的并行度下降,因此也无法直接就将计算位数直接加宽至最终结果的位数。这也是一个需要去权衡的问题,寻找一个最优项。

回到上面的问题,需要寻找另一种可行的计算方法。我最终采用的方法如下,但我不敢保证这就是最优的。

同样将每行pixel(32b)存入向量寄存器的低32位。然后使用insve插入指令合并一二行、三四行得到

{ 0 , 0 , r o w 1 , r o w 0 } \{0, 0, row_1, row_0 \} {0,0,row1,row0}
{ 0 , 0 , r o w 3 , r o w 2 } \{0, 0, row_3, row_2\} {0,0,row3,row2}

后续操作只对列元素进行,这里将列元素表示出来。

{ 0 ( 64 b ) , c o l 3 , c o l 2 , c o l 1 , c o l 0 , c o l 3 , c o l 2 , c o l 1 , c o l 0 } \{0(64b), col_3, col_2, col_1, col_0, col_3, col_2, col_1, col_0\} {0(64b),col3,col2,col1,col0,col3,col2,col1,col0}

统一结构,然后使用haddhsub横向加减扩展指令,源操作数都为同一个寄存器,实现相邻元素加减。得到

{ 0 ( 64 b ) , c o l 3 + c o l 2 , c o l 1 + c o l 0 , c o l 3 + c o l 2 , c o l 1 + c o l 0 } \{ 0(64b), col_3 + col_2, col_1 + col_0, col_3 + col_2, col_1 + col_0\} {0(64b),col3+col2,col1+col0,col3+col2,col1+col0}
{ 0 ( 64 b ) , c o l 3 − c o l 2 , c o l 1 − c o l 0 , c o l 3 − c o l 2 , c o l 1 − c o l 0 } \{ 0(64b), col_3 - col_2, col_1 - col_0, col_3 - col_2, col_1 - col_0\} {0(64b),col3col2,col1col0,col3col2,col1col0}

然后使用ilvr_w(32b)向量交错指令,取两个源寄存器的右64位数据(两个32位数据),分别存入目的寄存器的奇偶位置。也就得到

{ c o l 3 − c o l 2 , c o l 3 + c o l 2 , c o l 1 − c o l 0 , c o l 1 + c o l 0 , c o l 3 − c o l 2 , c o l 3 + c o l 2 , c o l 1 − c o l 0 , c o l 1 + c o l 0 } \{ col_3 - col_2, col_3 + col_2, col_1 - col_0, col_1 + col_0, col_3 - col_2, col_3 + col_2, col_1 - col_0, col_1 + col_0\} {col3col2,col3+col2,col1col0,col1+col0,col3col2,col3+col2,col1col0,col1+col0}

结果形式相同,只是奇数位的数据正负相反,但后续要求绝对值,因此不会造成任何影响。后续的操作基本一致,MIPS使用addvsubv向量加减指令完成一系列操作,基本上有一对一的指令。

但是,MIPS有比较灵活的向量交错指令,可以替代x86繁琐的交错过程。首先是这个过程
示意图
使用insve_d插入指令将下面寄存器的低64位插入目的寄存器高64位,上面寄存器的低64位保持原位,然后使用ilvl_d(64b)向量交错指令。取两个寄存器的高64位,上面插入目的寄存器偶数位(0),下面插入奇数位(1),得到结果。

其次是这个过程
示意图
可以直接用两个指令实现。首先是ilvod_h(16b)交错指令,选择两个寄存器的奇数位,上面寄存器插入目的寄存器的偶数位,下面寄存器插入奇数位。再是ilvev_h(16b)交错指令,选择偶数位置,上面寄存器插入偶数位置,下面寄存器插入奇数位置。

然后取绝对值,选择较大值,hadd_w相邻元素加,扩展得到32位,然后不进行混洗,直接把每个32位元素取出来求和,得到结果。

总结

对于优化的结果,在指令的数量上,两者的差别不大,由于相乘加指令的问题,可能导致MIPS指令数量相对大一点。但对于真正的性能,也就是周期数的比较,未知。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。
强化学习基于SATD来预测qp值的代码需要结合具体的算法和框架来实现,这里给出一个基于Deep Q-Learning算法的伪代码示例: ```python import numpy as np import tensorflow as tf # 定义神经网络模型 class QNetwork(tf.keras.Model): def __init__(self, state_dim, action_dim): super(QNetwork, self).__init__() self.fc1 = tf.keras.layers.Dense(64, activation='relu') self.fc2 = tf.keras.layers.Dense(32, activation='relu') self.fc3 = tf.keras.layers.Dense(action_dim, activation=None) def call(self, state): x = self.fc1(state) x = self.fc2(x) q_values = self.fc3(x) return q_values # 定义DQN算法 class DQNAgent: def __init__(self, state_dim, action_dim, lr=0.001, gamma=0.99, epsilon=1.0, epsilon_min=0.01, epsilon_decay=0.995): self.state_dim = state_dim self.action_dim = action_dim self.lr = lr self.gamma = gamma self.epsilon = epsilon self.epsilon_min = epsilon_min self.epsilon_decay = epsilon_decay self.q_network = QNetwork(state_dim, action_dim) self.target_network = QNetwork(state_dim, action_dim) self.optimizer = tf.keras.optimizers.Adam(lr=self.lr) self.loss_fn = tf.keras.losses.MeanSquaredError() # 选择动作 def act(self, state): # epsilon-greedy策略 if np.random.rand() <= self.epsilon: return np.random.randint(self.action_dim) else: q_values = self.q_network(state) return np.argmax(q_values[0]) # 训练网络 def train(self, replay_buffer, batch_size=32): # 从经验回放池随机采样一批数据 state_batch, action_batch, reward_batch, next_state_batch, done_batch = replay_buffer.sample(batch_size) # 计算目标Q值 next_q_values = self.target_network(next_state_batch) max_next_q_values = tf.reduce_max(next_q_values, axis=-1, keepdims=True) target_q_values = reward_batch + (1 - done_batch) * self.gamma * max_next_q_values # 计算当前Q值 with tf.GradientTape() as tape: q_values = self.q_network(state_batch) one_hot_actions = tf.one_hot(action_batch, depth=self.action_dim) current_q_values = tf.reduce_sum(tf.multiply(q_values, one_hot_actions), axis=-1) # 计算损失 loss = self.loss_fn(target_q_values, current_q_values) # 计算梯度并更新网络参数 grads = tape.gradient(loss, self.q_network.trainable_variables) self.optimizer.apply_gradients(zip(grads, self.q_network.trainable_variables)) # 更新探索率 self.epsilon = max(self.epsilon * self.epsilon_decay, self.epsilon_min) # 更新目标网络参数 def update_target_network(self): self.target_network.set_weights(self.q_network.get_weights()) # 定义经验回放池 class ReplayBuffer: def __init__(self, buffer_size): self.buffer_size = buffer_size self.buffer = [] # 添加一条经验数据 def add(self, state, action, reward, next_state, done): experience = (state, action, reward, next_state, done) if len(self.buffer) >= self.buffer_size: self.buffer.pop(0) self.buffer.append(experience) # 从经验回放池随机采样一批数据 def sample(self, batch_size): indices = np.random.randint(0, len(self.buffer), batch_size) state_batch, action_batch, reward_batch, next_state_batch, done_batch = [], [], [], [], [] for i in indices: state, action, reward, next_state, done = self.buffer[i] state_batch.append(state) action_batch.append(action) reward_batch.append(reward) next_state_batch.append(next_state) done_batch.append(done) return np.array(state_batch), np.array(action_batch), np.array(reward_batch), np.array(next_state_batch), np.array(done_batch) # 定义主函数 def main(): # 定义参数 state_dim = 2 action_dim = 1 buffer_size = 10000 batch_size = 32 lr = 0.001 gamma = 0.99 epsilon = 1.0 epsilon_min = 0.01 epsilon_decay = 0.995 max_episodes = 1000 max_steps = 100 update_interval = 10 update_target_interval = 100 # 创建DQN智能体和经验回放池 agent = DQNAgent(state_dim, action_dim, lr, gamma, epsilon, epsilon_min, epsilon_decay) replay_buffer = ReplayBuffer(buffer_size) # 训练智能体 for episode in range(max_episodes): state = np.random.rand(1, state_dim) for step in range(max_steps): # 选择动作并执行 action = agent.act(state) next_state = np.random.rand(1, state_dim) reward = -1 * abs(next_state[0][0] - next_state[0][1]) done = (step == max_steps - 1) # 添加经验数据到经验回放池 replay_buffer.add(state, action, reward, next_state, done) # 训练智能体 if len(replay_buffer.buffer) >= batch_size: agent.train(replay_buffer, batch_size) # 更新状态 state = next_state # 更新目标网络参数 if step % update_target_interval == 0: agent.update_target_network() # 打印信息 if step % update_interval == 0: print("Episode: {}, Step: {}, Epsilon: {:.4f}, Reward: {:.4f}".format(episode, step, agent.epsilon, reward)) if __name__ == "__main__": main() ``` 在这个伪代码示例,我们使用了一个简单的2维状态空间和1维动作空间,用于模拟视频编码SATD和QP值。具体来说,我们在每个状态随机生成两个数作为SATD和QP值,并根据它们的差值来计算奖励。在训练过程,我们使用了一个基于经验回放池的DQN算法来学习最优的QP值预测策略。在每个训练步骤,我们随机选择一个动作并执行,然后将经验数据添加到经验回放池。当经验回放池的数据达到一定数量时,我们从随机采样一批数据进行训练,并使用梯度下降算法来更新网络参数。同时,我们还定期更新目标网络参数,以提高算法的稳定性。在训练过程,我们还使用了一个探索策略来平衡探索和利用,从而避免陷入局部最优解。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值