Shulou(Shulou.com)06/03 Report--

Code structure (1) Infrastructure

Looking at the source code logically is the clearest way to learn the code, so the memory of the code will be greatly improved.

Being able to find logical relationships in complex code structures is also a very important skill.

These are the main code logic relationships of dm dedup.

Because its main design has been introduced in the previous article, we analyze the code flow directly here.

4. Code structure (1) dm_dedup_map of entry of I _ ramp

1. Dm_dedup_map: this is the main call to the API from dm.c- > dm_dedup.c

① chunk data's segmentation of it.

The first thing to explain is that the process of chunk bio in the figure is implemented by split_and_process_bio in dm.c.

While (ci.sector_count & &! error) {error = _ split_and_process_non_flush (& ci); if (current- > bio_list & & ci.sector_count & &! error) {struct bio * b = bio_split (bio, bio_sectors (bio)-ci.sector_count, GFP_NOIO, & md- > queue- > bio_split) Ci.io- > orig_bio = b; bio_chain (b, bio); ret = generic_make_request (bio); break;}}

The core of this paragraph is that the large BIO of split becomes aligned in some way.

If you understand how to align split, you must analyze _ split_and_process_non_flush

Static int _ split_and_process_non_flush (struct clone_info * ci) {struct bio * bio = ci- > bio; struct dm_target * ti; unsigned len; int r; ti = dm_table_find_target (ci- > map, ci- > sector); if (! dm_target_is_valid (ti)) return-EIO; if (unlikely (_ process_abnormal_io (ci, ti, & r)) return r If (bio_op (bio) = = REQ_OP_ZONE_REPORT) len = ci- > sector_count; else len = min_t (sector_t, max_io_len (ci- > sector, ti), ci- > sector_count); r = _ clone_and_map_data_bio (ci, ti, ci- > sector, & len); if (r

Sector + = len; ci- > sector_count-= len; return 0;}

First of all, there are several important issues in the Icano alignment split:

How exactly does ① split BIO?

Syncopation should be easy for readers to understand, that is, keep going to ci- > sector + = len and ci- > sector_count-= len.

By continuously increasing ci- > sector through len, and then decreasing the total amount of ci- > sector_count

Make a sub_BIOs that is split one by one.

Why does ② say that syncopation is aligned?

This involves the size of the len, and here's an example:

Bio: [bi _ sector:3 size=8] should be segmented. What does it look like?

If you divide it according to size=4? That should turn out to be:

3% 4 = 3, bio_split_1 = [1 bipolar sectorgroup 3 recorder 1], t_size = 8-1% 7 countries sectorgroup 4

4% 4 = 0, bio_split_2 = [2 percent bipolar sectoergroup 4 people 2 minutes sizecoat 4], tweesizer = 7-4 percent 3 percent percent secorgroup 8

8% 4 = 0 recording biochemistry splitters 3 = [3 minutes bivalent sectoervus 8 minicolor 3], tactile size3 = 3-4 bioglypes 1 countries biogeographies secorl11

In fact, the rule we have calculated here is the logical relationship of the max_io_len code:

Static sector_t max_io_len (sector_t sector, struct dm_target * ti) {sector_t len = max_io_len_target_boundary (sector, ti); sector_t offset, max_len; / * * Does the target need to split even further? * / if (ti- > max_io_len) {offset = dm_target_offset (ti, sector) If (unlikely (ti- > max_io_len & (ti- > max_io_len-1)) max_len = sector_div (offset, ti- > max_io_len); else max_len = offset & (ti- > max_io_len-1); max_len = ti- > max_io_len-max_len; if (len > max_len) len = max_len } return len;}

③ understands the method of sharding, so another question is, what is the ti > max_io_len of max_io_len 's n%splt_size?

We also need to figure it out according to how much it is divided.

The process is simple, and the general process is to push up to find the assignment, initial meaning, and configurability of the value.

It turns out that this value is determined by a parameter block_size passed in dm_dedup_ctr, that is, the block size.

This block_size is the unit of hash index, which is constrained within the range of 4k to 1m in dm_dedup.

# define MIN_DATA_DEV_BLOCK_SIZE (4 1024)

# define MAX_DATA_DEV_BLOCK_SIZE (1024 1024)

OK, at present, we conventionally think that it is page size 4k, so it is easy to understand.

The reason why the bio after being aligned with the split is to align the split is that the alignment split bio can correspond to a pbn, so that it can be represented by the hash of a pbn.

② multithreading processes each chunk_bio

Static int dm_dedup_map (struct dm_target * ti, struct bio * bio) {dedup_defer_bio (ti- > private, bio); return DM_MAPIO_SUBMITTED;} static void dedup_defer_bio (struct dedup_config * dc, struct bio * bio) {struct dedup_work * data; data = mempool_alloc (dc- > dedup_work_pool, GFP_NOIO); if (! data) {bio- > bi_error =-ENOMEM; bio_endio (bio) Return;} data- > bio = bio; data- > config = dc; INIT_WORK (& (data- > worker), do_work); queue_work (dc- > workqueue, & (data- > worker));}

The principle of this code is very simple, using mempool to apply for work and queue_work to distribute requests to each cpu.

If you want to do better here, you can make a cpu pool that allows you to configure its cpu affinity, single cpu command queue depth (maximum IO merge size) when creating a device.

Static void process_bio (struct dedup_config * dc, struct bio * bio) {int r; if (bio- > bi_opf & (REQ_PREFLUSH | REQ_FUA) & &! bio_sectors (bio)) {r = dc- > mdops- > flush_meta (dc- > bmd); if (r = 0) dc- > writes_after_flush = 0; do_io_remap_device (dc, bio); return } switch (bio_data_dir (bio)) {case READ: r = handle_read (dc, bio); break; case WRITE: r = handle_write (dc, bio);} if (r

Bi_error = r; bio_endio (bio);}}

Finally, parse the direction of bio read and write and then distribute the request to handle_read and handle_write.

If you look at it carefully, the reader should have clearly understood that the flow of map is: a process in which dm_bio (Big bio) is aligned with split with block_size and then processed with multiple cpu.

This is the engine of the dm-dedup, and many people may ask, why is it in the form of asynchronous processing? why not just finish the work of dm_bio in the task where the dedup is distributed at the top?

I think this is mainly due to the fact that it takes a lot of time for dedup to calculate hash index, so the final performance of this program in the case of high concurrency may be on multiple cpu computing hash.

If you do hash in the task of dm_bio, it is tantamount to no pipelined concurrency capability. If a single thread is counting hash, computing will be the bottleneck of io performance. This problem is well solved here, but it does not take into account the merging of io O (if it cannot be merged, it may result in huge latency) and the balance of request queue depth of each cpu.

[this article is only posted by 51cto blogger "underlying Storage Technology" https://blog.51cto.com/12580077, official account release: storage Valley], if you need to reprint, please contact me, thank you.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.