2. 程式人生 > >兩種形式的dma 實現memory copy程式碼

兩種形式的dma 實現memory copy程式碼

阿新 • • 發佈：2019-01-04

在飛思卡爾的時候，需要用SDMA實現記憶體到記憶體memory copy的功能，需要做兩部分的工作：

1：在DMA controller中加入M2M的支援。

2：寫一個驅動來呼叫DMA controller的M2M功能。

上面的2實際上對於不同的SoC來講，思路是一樣的，有通用性，在這裡總結下。

當時在實現的時候，用了兩種方法：

1：cyclic, 用dma_alloc_coherent分配兩段dma 記憶體空間， 一段做src, 一段做dst. 呼叫DMA controller介面來將src中的資料往dst中拷貝。因為DMA操作的是物理內地址上連續的記憶體空間，dma_alloc_coherent分配不了太大的連續實體地址空間，所以，僅僅能實現小批量資料的M2M拷貝。

2：sg, 用dma_alloc_coherent分配很多段dma 記憶體空間，一半大小的空間做src,一半大小的空間做dst.通過device_prep_dma_sg來將各自獨立的src/dst空間連結起來。這個，可以將若干段分散的實體地址連結成邏輯上連續的，可以實現較大資料的拷貝。

 13 The slave DMA usage consists of following steps:
 14 1. Allocate a DMA slave channel
 15 2. Set slave and controller specific parameters
 16 3. Get a descriptor for transaction
 
 
17 4. Submit the transaction
 18 5. Issue pending requests and wait for callback notification

 20 1. Allocate a DMA slave channel

 27    Interface:
 28         struct dma_chan *dma_request_channel(dma_cap_mask_t mask,
 29                         dma_filter_fn filter_fn,
 30                         void *filter_param);


 48 2. Set slave and controller specific parameters

 61    Interface:
 62         int dmaengine_slave_config(struct dma_chan *chan,
 63                                   struct dma_slave_config *config)
 70 3. Get a descriptor for transaction

 86    Interface:
 87         struct dma_async_tx_descriptor *(*chan->device->device_prep_slave_sg)(
 88                 struct dma_chan *chan, struct scatterlist *sgl,
 89                 unsigned int sg_len, enum dma_data_direction direction,
 90                 unsigned long flags);
 91 
 92         struct dma_async_tx_descriptor *(*chan->device->device_prep_dma_cyclic)(
 93                 struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
 94                 size_t period_len, enum dma_data_direction direction);
 95 
 96         struct dma_async_tx_descriptor *(*device_prep_interleaved_dma)(
 97                 struct dma_chan *chan, struct dma_interleaved_template *xt,
 98                 unsigned long flags);
139 4. Submit the transaction

144    Interface:
145         dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)


153 5. Issue pending DMA requests and wait for callback notification

163    Interface:
164         void dma_async_issue_pending(struct dma_chan *chan);


傳輸結束的時候可以用：
168 1. int dmaengine_terminate_all(struct dma_chan *chan)


看下面程式碼：
1: cyclic方式實現
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/mman.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/fs.h>
#include <linux/version.h>
#include <linux/delay.h>
#include <mach/dma.h>

#include <linux/dmaengine.h>
#include <linux/device.h>

#include <linux/io.h>
#include <linux/delay.h>

static int gMajor; //major number of device
static struct class *dma_tm_class;
static char *wbuf;
static char *rbuf;
static dma_addr_t wpaddr;
static dma_addr_t rpaddr;

struct dma_chan *dma_m2m_chan;

struct completion dma_m2m_ok;

#define SDMA_BUF_SIZE  1024

static bool dma_m2m_filter(struct dma_chan *chan, void *param)
{
if (!imx_dma_is_general_purpose(chan))
return false;
chan->private = param;
return true;
}

int sdma_open(struct inode * inode, struct file * filp)
{
dma_cap_mask_t dma_m2m_mask;
struct imx_dma_data m2m_dma_data = {0};


init_completion(&dma_m2m_ok);


dma_cap_zero(dma_m2m_mask);
dma_cap_set(DMA_SLAVE, dma_m2m_mask);
m2m_dma_data.peripheral_type = IMX_DMATYPE_MEMORY;
m2m_dma_data.priority = DMA_PRIO_HIGH;

dma_m2m_chan = dma_request_channel(dma_m2m_mask, dma_m2m_filter, &m2m_dma_data);
if (!dma_m2m_chan) {
printk("Error opening the SDMA memory to memory channel\n");
return -EINVAL;
}


wbuf = dma_alloc_coherent(NULL, SDMA_BUF_SIZE, &wpaddr, GFP_DMA);
rbuf = dma_alloc_coherent(NULL, SDMA_BUF_SIZE, &rpaddr, GFP_DMA);


return 0;
}

int sdma_release(struct inode * inode, struct file * filp)
{
dma_release_channel(dma_m2m_chan);
dma_m2m_chan = NULL;
dma_free_coherent(NULL, SDMA_BUF_SIZE, wbuf, wpaddr);
dma_free_coherent(NULL, SDMA_BUF_SIZE, rbuf, rpaddr);


return 0;
}

ssize_t sdma_read (struct file *filp, char __user * buf, size_t count, loff_t * offset)
{
int i;

wait_for_completion(&dma_m2m_ok);
for (i=0; i<SDMA_BUF_SIZE; i++) {
printk("src_data_%d = %x\n",i, *(wbuf+i) );
}
for (i=0; i<SDMA_BUF_SIZE; i++) {
printk("dst_data_%d = %x\n",i, *(rbuf+i) );
}

return 0;
}

static void dma_m2m_callback(void *data)
{
printk("in %s\n",__func__);
complete(&dma_m2m_ok);
return ;
}

ssize_t sdma_write(struct file * filp, const char __user * buf, size_t count, loff_t * offset)
{
u32 *index1;
struct dma_slave_config dma_m2m_config;
struct dma_async_tx_descriptor *dma_m2m_desc;
int i;
index1 = wbuf;
for (i=0; i<SDMA_BUF_SIZE; i++) {
*(index1 + i) = 0x12345678;
}

for (i=0; i<SDMA_BUF_SIZE; i++) {
printk("%d : %x\n",i, *(wbuf+i) );
}

dma_m2m_config.direction = DMA_MEM_TO_MEM;
dma_m2m_config.dst_addr = rpaddr;
dma_m2m_config.src_addr = wpaddr;
dma_m2m_config.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
dma_m2m_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
dma_m2m_config.dst_maxburst = 4;
dma_m2m_config.src_maxburst = 4;
dmaengine_slave_config(dma_m2m_chan, &dma_m2m_config);
dma_m2m_desc = dma_m2m_chan->device->device_prep_dma_cyclic(
dma_m2m_chan, NULL, SDMA_BUF_SIZE, SDMA_BUF_SIZE/2, DMA_MEM_TO_MEM);
dma_m2m_desc->callback = dma_m2m_callback;
dmaengine_submit(dma_m2m_desc);
return 0;
}

struct file_operations dma_fops = {
open:sdma_open,
release:sdma_release,
read:sdma_read,
write:sdma_write,
};

int __init sdma_init_module(void)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
struct device *temp_class;
#else
struct class_device *temp_class;
#endif
int error;


/* register a character device */
error = register_chrdev(0, "sdma_test", &dma_fops);
if (error < 0) {
printk("SDMA test driver can't get major number\n");
return error;
}
gMajor = error;
printk("SDMA test major number = %d\n",gMajor);


dma_tm_class = class_create(THIS_MODULE, "sdma_test");
if (IS_ERR(dma_tm_class)) {
printk(KERN_ERR "Error creating sdma test module class.\n");
unregister_chrdev(gMajor, "sdma_test");
return PTR_ERR(dma_tm_class);
}


#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
temp_class = device_create(dma_tm_class, NULL,
   MKDEV(gMajor, 0), NULL, "sdma_test");
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
temp_class = device_create(dma_tm_class, NULL,
   MKDEV(gMajor, 0), "sdma_test");
#else
temp_class = class_device_create(dma_tm_class, NULL,
     MKDEV(gMajor, 0), NULL,
     "sdma_test");
#endif
if (IS_ERR(temp_class)) {
printk(KERN_ERR "Error creating sdma test class device.\n");
class_destroy(dma_tm_class);
unregister_chrdev(gMajor, "sdma_test");
return -1;
}


printk("SDMA test Driver Module loaded\n");
return 0;
}

static void sdma_cleanup_module(void)
{
unregister_chrdev(gMajor, "sdma_test");
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
device_destroy(dma_tm_class, MKDEV(gMajor, 0));
#else
class_device_destroy(dma_tm_class, MKDEV(gMajor, 0));
#endif
class_destroy(dma_tm_class);


printk("SDMA test Driver Module Unloaded\n");
}

module_init(sdma_init_module);
module_exit(sdma_cleanup_module);

2：sg方式實現

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/mman.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/fs.h>
#include <linux/version.h>
#include <linux/delay.h>
#include <mach/dma.h>


#include <linux/dmaengine.h>
#include <linux/device.h>


#include <linux/io.h>
#include <linux/delay.h>


static int gMajor; /* major number of device */
static struct class *dma_tm_class;
u32 *wbuf, *wbuf2, *wbuf3, *wbuf4;
u32 *rbuf, *rbuf2, *rbuf3, *rbuf4;


struct dma_chan *dma_m2m_chan;


struct completion dma_m2m_ok;


struct scatterlist sg[4], sg2[4];


#define SDMA_BUF_SIZE  1024*60






static bool dma_m2m_filter(struct dma_chan *chan, void *param)
{
if (!imx_dma_is_general_purpose(chan))
return false;
chan->private = param;
return true;
}


int sdma_open(struct inode *inode, struct file *filp)
{
dma_cap_mask_t dma_m2m_mask;
struct imx_dma_data m2m_dma_data;


init_completion(&dma_m2m_ok);


dma_cap_zero(dma_m2m_mask);
dma_cap_set(DMA_SLAVE, dma_m2m_mask);
m2m_dma_data.peripheral_type = IMX_DMATYPE_MEMORY;
m2m_dma_data.priority = DMA_PRIO_HIGH;
dma_m2m_chan = dma_request_channel(dma_m2m_mask, dma_m2m_filter,
&m2m_dma_data);
if (!dma_m2m_chan) {
printk("Error opening the SDMA memory to memory channel\n");
return -EINVAL;
}


wbuf = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!wbuf) {
printk("error wbuf !!!!!!!!!!!\n");
return -1;
}


wbuf2 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!wbuf2) {
printk("error wbuf2 !!!!!!!!!!!\n");
return -1;
}


wbuf3 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!wbuf3) {
printk("error wbuf3 !!!!!!!!!!!\n");
return -1;
}


wbuf4 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!wbuf4) {
printk("error wbuf4 !!!!!!!!!!!\n");
return -1;
}


rbuf = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!rbuf) {
printk("error rbuf !!!!!!!!!!!\n");
return -1;
}


rbuf2 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!rbuf2) {
printk("error rbuf2 !!!!!!!!!!!\n");
return -1;
}


rbuf3 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!rbuf3) {
printk("error rbuf3 !!!!!!!!!!!\n");
return -1;
}


rbuf4 = kzalloc(SDMA_BUF_SIZE, GFP_DMA);
if(!rbuf4) {
printk("error rbuf4 !!!!!!!!!!!\n");
return -1;
}


return 0;
}


int sdma_release(struct inode * inode, struct file * filp)
{
dmaengine_terminate_all(dma_m2m_chan);
dma_release_channel(dma_m2m_chan);
dma_m2m_chan = NULL;
kfree(wbuf);
kfree(wbuf2);
kfree(wbuf3);
kfree(rbuf);
kfree(rbuf2);
kfree(rbuf3);
return 0;
}


ssize_t sdma_read (struct file *filp, char __user * buf, size_t count,
loff_t * offset)
{
int i;
#if 0
for (i=0; i<SDMA_BUF_SIZE/4; i++) {
printk("dst data_%d : %x\n", i, *(rbuf+i));
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
printk("dst data2_%d : %x\n", i, *(rbuf2+i));
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
printk("dst data3_%d : %x\n", i, *(rbuf3+i));
}
#endif


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
if (*(rbuf+i) != *(wbuf+i)) {
printk("buffer 1 copy falled!\n");
return 0;
}
}
printk("buffer 1 copy passed!\n");


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
if (*(rbuf2+i) != *(wbuf2+i)) {
printk("buffer 2 copy falled!\n");
return 0;
}
}
printk("buffer 2 copy passed!\n");


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
if (*(rbuf3+i) != *(wbuf3+i)) {
printk("buffer 3 copy falled!\n");
return 0;
}
}
printk("buffer 3 copy passed!\n");


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
if (*(rbuf4+i) != *(wbuf4+i)) {
printk("buffer 4 copy falled!\n");
return 0;
}
}
printk("buffer 4 copy passed!\n");


return 0;
}


static void dma_m2m_callback(void *data)
{
complete(&dma_m2m_ok);
return ;
}


ssize_t sdma_write(struct file * filp, const char __user * buf, size_t count,
loff_t * offset)
{
u32 *index1, *index2, *index3, *index4, i, ret;
struct dma_slave_config dma_m2m_config;
struct dma_async_tx_descriptor *dma_m2m_desc;
index1 = wbuf;
index2 = wbuf2;
index3 = wbuf3;
index4 = wbuf4;
struct timeval end_time;
unsigned long end, start;
for (i=0; i<SDMA_BUF_SIZE/4; i++) {
*(index1 + i) = 0x12121212;
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
*(index2 + i) = 0x34343434;
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
*(index3 + i) = 0x56565656;
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
*(index4 + i) = 0x78787878;
}


#if 0
for (i=0; i<SDMA_BUF_SIZE/4; i++) {
printk("input data_%d : %x\n", i, *(wbuf+i));
}


for (i=0; i<SDMA_BUF_SIZE/2/4; i++) {
printk("input data2_%d : %x\n", i, *(wbuf2+i));
}


for (i=0; i<SDMA_BUF_SIZE/4; i++) {
printk("input data3_%d : %x\n", i, *(wbuf3+i));
}
#endif
dma_m2m_config.direction = DMA_MEM_TO_MEM;
dma_m2m_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
dmaengine_slave_config(dma_m2m_chan, &dma_m2m_config);


sg_init_table(sg, 4);
sg_set_buf(&sg[0], wbuf, SDMA_BUF_SIZE);
sg_set_buf(&sg[1], wbuf2, SDMA_BUF_SIZE);
sg_set_buf(&sg[2], wbuf3, SDMA_BUF_SIZE);
sg_set_buf(&sg[3], wbuf4, SDMA_BUF_SIZE);
ret = dma_map_sg(NULL, sg, 4, dma_m2m_config.direction);


sg_init_table(sg2, 4);
sg_set_buf(&sg2[0], rbuf, SDMA_BUF_SIZE);
sg_set_buf(&sg2[1], rbuf2, SDMA_BUF_SIZE);
sg_set_buf(&sg2[2], rbuf3, SDMA_BUF_SIZE);
sg_set_buf(&sg2[3], rbuf4, SDMA_BUF_SIZE);
ret = dma_map_sg(NULL, sg2, 4, dma_m2m_config.direction);


dma_m2m_desc = dma_m2m_chan->device->
device_prep_dma_sg(dma_m2m_chan, sg2, 4, sg, 4, 0);
dma_m2m_desc->callback = dma_m2m_callback;
//printk("1111111111111\n");
do_gettimeofday(&end_time);
start = end_time.tv_sec*1000000 + end_time.tv_usec;


dmaengine_submit(dma_m2m_desc);
dma_async_issue_pending(dma_m2m_chan);


wait_for_completion(&dma_m2m_ok);
//printk("2222222222222\n");
do_gettimeofday(&end_time);
end = end_time.tv_sec*1000000 + end_time.tv_usec;
printk("end - start = %d\n", end - start);
dma_unmap_sg(NULL, sg, 4, dma_m2m_config.direction);
dma_unmap_sg(NULL, sg2, 4, dma_m2m_config.direction);


return 0;
}


struct file_operations dma_fops = {
open:sdma_open,
release: sdma_release,
read:sdma_read,
write: sdma_write,
};


int __init sdma_init_module(void)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
struct device *temp_class;
#else
struct class_device *temp_class;
#endif
int error;


/* register a character device */
error = register_chrdev(0, "sdma_test", &dma_fops);
if (error < 0) {
printk("SDMA test driver can't get major number\n");
return error;
}
gMajor = error;
printk("SDMA test major number = %d\n",gMajor);


dma_tm_class = class_create(THIS_MODULE, "sdma_test");
if (IS_ERR(dma_tm_class)) {
printk(KERN_ERR "Error creating sdma test module class.\n");
unregister_chrdev(gMajor, "sdma_test");
return PTR_ERR(dma_tm_class);
}


#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
temp_class = device_create(dma_tm_class, NULL,
  MKDEV(gMajor, 0), NULL, "sdma_test");
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
temp_class = device_create(dma_tm_class, NULL,
  MKDEV(gMajor, 0), "sdma_test");
#else
temp_class = class_device_create(dma_tm_class, NULL,
    MKDEV(gMajor, 0), NULL,
    "sdma_test");
#endif
if (IS_ERR(temp_class)) {
printk(KERN_ERR "Error creating sdma test class device.\n");
class_destroy(dma_tm_class);
unregister_chrdev(gMajor, "sdma_test");
return -1;
}


printk("SDMA test Driver Module loaded\n");
return 0;
}


static void sdma_cleanup_module(void)
{
unregister_chrdev(gMajor, "sdma_test");
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
device_destroy(dma_tm_class, MKDEV(gMajor, 0));
#else
class_device_destroy(dma_tm_class, MKDEV(gMajor, 0));
#endif
class_destroy(dma_tm_class);


printk("SDMA test Driver Module Unloaded\n");
}


module_init(sdma_init_module);
module_exit(sdma_cleanup_module);

當時測出大約1秒鐘可以拷貝50M的資料，但是客戶還覺得不滿意。

相關推薦

兩種形式的dma 實現memory copy程式碼

在飛思卡爾的時候，需要用SDMA實現記憶體到記憶體memory copy的功能，需要做兩部分的工作： 1：在DMA controller中加入M2M的支援。 2：寫一個驅動來呼叫DMA controller的M2M功能。 上面的2實際上對於不同的SoC來講，思路是一樣的，有

SQL 關於apply的兩種形式cross apply 和 outer apply

插入數據 sele 我們 如果 href 新的 desc 得出 tro 轉載：http://www.cnblogs.com/Leo_wl/archive/2013/04/02/2997012.html apply有兩種形式： cross apply 和 out

5.1.1 字符串格式化的兩種形式

建模 表示 () 關鍵字 format dong 相對 模板類 align 　　如果需要將其他類型的數據轉換為字符串，或者嵌入其他字符串或模板中再進行輸出，就需要用到字符串格式化。Python中字符串格式化的的格式如下所示，格式運算符%之前的部分為格式字符串，之後的部分為需

列表存儲的兩種形式

family 技術分享 內存 height 表結構 下列表 順序表 成了 空間 1.順序表結構 32位的操作系統每個存儲空間占四個字節。 然後列表中同類型的數據的元素的地址是相連的比如下圖 [200,390,78,1212] 假設第一個元素的地址的0x27(x表示的是十六進

兩種方法簡單實現網站隨機語錄的顯示

創建 arr ava 一個 調用 har 實現 產生 charset 方法一：簡單的JavaScript文本輸出 這個方法相對來說更簡單，但是因為語錄是自己添加的，數量也就更少，更單一。閑魚目前用的就是這個，要求不高也還行。類似這類的代碼也很多，這裏提到的是

python 類C數組的兩種形式：list -->內容可變, tuple --->內容不可變

size print app http append 列表 itl c數組 multi python 中的列表相當與 C 中的數組，列表：list 初始化使用[ ]， 元組：tuple 初始化使用（）；一、列表list 1 #!/usr/bin/python 2 3

Logistic回歸的兩種形式y=0/1,y=+1/-1

兩種 ons class 似然 com clas blank function 函數 第一種形式：y=0/1 第二種形式：y=+1/-1 第一種形式的損失函數可由極大似然估計推出: 第二種形式的損失函數： ， 參考：https://en.wikipedia.org

深入研究Spring-IoC:兩種設計和實現

一.Sprng IOC 解除了物件例項化造成的耦合現象；將物件的建立和對生命週期的管理交給了容器來管理，可以通過注入的方式將IOC容器中的物件供給開發者使用，極大方便了開發。 二.IOC容器系列的兩種設計和實現–BeanFactory和ApplicationCont

一列數字的規則如下；1，1，2，3，5，8，13，21，34........ 求第30位數字是多少，用遞規和非遞迴兩種方法演算法實現

斐波納契數列（Fibonacci Sequence），又稱黃金分割數列。在數學上，斐波納契數列以如下被以遞迴的方法定義：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）在現代物理、準晶體結構、化學等領域，斐波納契數列都有直接的應用，現在我從演算法的角度，利用遞迴和非

ReactNative 自定義Android原生模組的兩種形式

ReactNative 自定義Android原生模組的兩種形式 1.原生View模組 繼承SimpleViewManager<返回View型別> 必須重寫getName()和createViewInstance(ThemedReactContext context

水仙花問題的兩種C語言實現方案

方法一：使用除法以及取模運算得到三位數的每一位數值。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<math.h> int ma

opencv(3)-floodFill函式填充，兩種形式

第一種：聯通方式為，CV_FLOODFILL_FIXED_RANGE，彩色填充 # -*- coding=GBK -*- import cv2 import numpy as np def fill_image(image): copy_image = image

爬蟲-基於scrapy-redis兩種形式的分散式爬蟲

redis分散式部署     1.scrapy框架是否可以自己實現分散式？ 　　　　- 不可以。原因有二。 　　　　　　其一：因為多臺機器上部署的scrapy會各自擁有各自的排程器，這樣就使得多臺機器無法分配start_urls列表中的url。（多臺機器無法共享同

基於scrapy-redis兩種形式的分散式爬蟲

redis分散式部署     1.scrapy框架是否可以自己實現分散式？ 　　　　- 不可以。原因有二。 　　　　　　其一：因為多臺機器上部署的scrapy會各自擁有各自的排程器，這樣就使得多臺機器無法分配start_urls列表中的url。（多臺機器無法共享同

基於scrapy-redis兩種形式的分布式爬蟲

eset data- 流程 鏈接 -s efi snippet 調度器 imp redis分布式部署 1.scrapy框架是否可以自己實現分布式？ 　　　　- 不可以。原因有二。 　　　　　　其一：因為多臺機器上部署的scrapy會各自擁有各自的調度器，這樣就使得多

使用javascript和jquery兩種方法，實現密碼明文和密文的轉換

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&

c++運算子過載中的兩種形式以及常引用的使用

下面是c++運算子過載的兩種形式： 形式1： Point operator + (const Point& A,const Point& B) { return Point(A.x+B.x,A.y+B.y); } 形式2： ostream&

氣泡排序的兩種形式

#include <iostream> using namespace std; //..............方法1：氣泡排序（自上而下掃描，“重者沉”）.........................// void BubbleSort(int *list,int n) {  int i

Spring 註解@value引數值的兩種形式

首先，@value需要引數，這裡引數可以是兩種形式：@Value("#{configProperties['t1.msgname']}")或者@Value("${t1.msgname}")；其次，下面我們來看看如何使用這兩形式，在配置上有什麼區別：1、@Value("#{c

#include的兩種形式

通常我們在使用include指令的時候，有兩種形式： #include "file" #include <file> 比如我們想匯入I/0流標頭檔案，我們是這樣做的: #include <iostream> 如果我們有一個Person.h標頭檔