结束 - 文件系统核心存储引擎_实现(六)

最新推荐文章于 2024-08-21 18:16:36 发布
最新推荐文章于 2024-08-21 18:16:36 发布
阅读量157 收藏
点赞数
分类专栏： 文件系统大文件存储结构 文章标签： 链表 c++ linux

索引处理类 - 读流程实现

在这里插入图片描述

#include "common.h"
#include "file_op.h"
#include "index_handle.h"
#include "sstream"

using namespace std;
using namespace qiniu;

const static largefile::MMapOption mmap_option = {1024000, 4096, 4096}; /* 内存映射的参数 */
const static uint32_t main_blocksize = 1024 * 1024 * 64; /* 主块文件的大小 */
const static uint32_t bucket_size = 1000; /* 哈希桶的大小 */
static int32_t block_id = 1;
static int debug = 1;

int main(int argc, char *argv[])
{
    string mainblock_path;
    string index_path;
    int32_t ret = largefile::TFS_SUCCESS;

    cout << "Type your bockid :" <<endl;
    cin >> block_id;

    if (block_id < 1)
    {
        cerr << "Invalid bockid, exit." <<endl;
        exit(-1);
    }


    /* 1. 创建索引文件 */
    largefile::IndexHandle *index_handle = new largefile::IndexHandle(".", block_id);

    if (debug)
    {
        printf("Init index ...\n");
    }

    ret = index_handle->load(block_id, bucket_size, mmap_option);

    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "load index %d failed.\n", block_id);
        delete index_handle;
        exit(-2);
    }


    /* 2. 读取文件的 meta info */
    uint64_t file_id = 0;
    cout << "Type your file_id: "<<endl;
    cin >> file_id;

    if (file_id < 1)
    {
        cerr << "Invalid fileid, exit. " <<endl;
    }

    largefile::Metalnfo meta;

    ret = index_handle->read_segment_meta(file_id, meta); /* read_segment_meta */
    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "read_segment_meta error. file_id: %lu, ret: %d\n", file_id, ret);
        exit(-3);
    }


    /* 3. 根据meta info 读取文件 */
    stringstream tmp_stream;
    tmp_stream << "." << largefile::MAINBLOCK_DIR_PREFIX << block_id;
    tmp_stream >> mainblock_path;

    largefile::FileOperation *mainblock = new largefile::FileOperation(mainblock_path, O_RDWR);
    char *buffer = new char[meta.get_size() + 1];

    ret = mainblock->pread_file(buffer, meta.get_size(), meta.get_offset());
    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "read from main block failed. ret: %d, reason: %s \n", ret, strerror(errno));
        mainblock->close_file();

        delete mainblock;
        delete index_handle;
        exit(-3);
    }

    buffer[meta.get_size()] = '\0';
    printf("read: %d: content: %s \n", meta.get_size(), buffer);

    mainblock->close_file();
    delete mainblock;
    delete index_handle;

    return 0;
}

编译:

g++ block_read_test.cpp file_op.cpp index_handle.cpp mmap_file.cpp  mmap_file_op.cpp -o block_read_test

执行(很明显错误了, 但是我并不知道, 因为这是别人的思想, 我需要反复看 UML 图, 和了解它的思想才能解决):

在这里插入图片描述

索引处理类 - 删除流程实现

在这里插入图片描述

#include "common.h"
#include "file_op.h"
#include "index_handle.h"
#include "sstream"

using namespace std;
using namespace qiniu;

const static largefile::MMapOption mmap_option = {1024000, 4096, 4096}; /* 内存映射的参数 */
const static uint32_t main_blocksize = 1024 * 1024 * 64; /* 主块文件的大小 */
const static uint32_t bucket_size = 1000; /* 哈希桶的大小 */
static int32_t block_id = 1;
static int debug = 1;

int main(int argc, char *argv[])
{
    string mainblock_path;
    string index_path;
    int32_t ret = largefile::TFS_SUCCESS;

    cout << "Type your bockid :" <<endl;
    cin >> block_id;

    if (block_id < 1)
    {
        cerr << "Invalid bockid, exit." <<endl;
        exit(-1);
    }


    /* 1. 创建索引文件 */
    largefile::IndexHandle *index_handle = new largefile::IndexHandle(".", block_id);

    if (debug)
    {
        printf("Init index ...\n");
    }

    ret = index_handle->load(block_id, bucket_size, mmap_option);

    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "load index %d failed.\n", block_id);
        delete index_handle;
        exit(-2);
    }


    /* 2. 删除指定文件的 meta info */
    uint64_t file_id = 0;
    cout << "Type your file_id: "<<endl;
    cin >> file_id;

    if (file_id < 1)
    {
        cerr << "Invalid fileid, exit. " <<endl;
    }

    largefile::Metalnfo meta;

    ret = index_handle->read_segment_meta(file_id, meta); /* read_segment_meta */
    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "read_segment_meta error. file_id: %lu, ret: %d\n", file_id, ret);
        exit(-3);
    }

    ret = index_handle->delete_segment_meta(file_id);
    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "delete index failed. file_id: %lu. ret: %d \n", file_id, ret);
    }

    ret = index_handle->flush(); 

    if (ret != largefile::TFS_SUCCESS)
    {
        fprintf(stderr, "flush mainblock %d failed file no: %lu \n", block_id, file_id);
        exit(-4);
    }


    printf("delete successfully ! \n");
    delete index_handle;

    return 0;
}

编译:

g++ block_delete_test.cpp file_op.cpp index_handle.cpp mmap_file.cpp  mmap_file_op.cpp -o block_delete_test

执行:

(我人傻了, 可能手抖或走神写错代码, 完全测试失败! 别问我错误原因, 我不知道, 因为这代码是别人的思想, 我只是刚接触, 不过没有关系, 第一轮我也是有目的的-- 就是看到思想, 和为啥它这么写, 第二次再来, 我觉得就没问题)

在这里插入图片描述

可重用 meta 节点实现

在这里插入图片描述

#include "common.h"
#include "index_handle.h"
#include "sstream"

static int debug = 1;

namespace qiniu
{
    namespace largefile
    {
        /* IndexHandle(const std::string &base_path, const uint32_t main_block_id); */
        IndexHandle::IndexHandle(const std::string &base_path, const uint32_t main_block_id)
        {
            /* create file_op_ handle object */
            std::stringstream tmp_stream;
            tmp_stream << base_path << INDEX_DIR_PREFIX << main_block_id; /* /root/weifc/index/ */

            std::string index_path;
            tmp_stream >> index_path;

            file_op_ = new MMapFileOperation(index_path, O_CREAT | O_RDWR | O_LARGEFILE);
            is_load_ = false;
        }


        IndexHandle::~IndexHandle()
        {
            if (file_op_)
            {
                delete file_op_;
                file_op_ = NULL;
            }
        }


        int IndexHandle::create(const uint32_t logic_block_id, const int32_t bucket_size, const MMapOption map_optiont)
        {
            int ret = TFS_SUCCESS;

            if (debug)
            {
                printf("create index, block id: %u, bucket size: %d, max_mmap_size: %d, first mmap size: %d, per mmap size: %d\n",
                        logic_block_id, bucket_size, map_optiont.max_mmap_size_, map_optiont.first_mmap_size_, map_optiont.per_mmap_size_);
            }

            if (is_load_)
            {
                return EXIT_INDEX_ALREADY_LOADED_ERROR;
            }

            int64_t file_size = file_op_->get_file_size();

            if (file_size < 0)
            {
                return TFS_ERROR;
            }else if(file_size == 0) /* empty file */
            {
                IndexHeader i_header;
                i_header.block_info_.block_id_ = logic_block_id;
                i_header.block_info_.seq_no_ = 1;
                i_header.bucket_size_ = bucket_size;

                i_header.index_file_size_ = sizeof(IndexHandle) + bucket_size * sizeof(int32_t);

                /* index header + total buckets */
                char *init_data = new char[i_header.index_file_size_];
                memcpy(init_data, &i_header, sizeof(IndexHandle));
                memset(init_data + sizeof(IndexHandle), 0, i_header.index_file_size_ - sizeof(IndexHandle));

                /* write index header and buckets into file */
                ret = file_op_->pwrite_file(init_data, i_header.index_file_size_, 0);

                delete []init_data;
                init_data = NULL;

                if (ret != TFS_ERROR)
                {
                    return ret;
                }

                ret = file_op_->flush_file();
                if (ret != TFS_SUCCESS)
                {
                    return ret;
                }
            }else /* file size > 0, index already exist */
            {
                return EXIT_META_UNEXPECT_FOUND_ERROR;
            }
            
            ret = file_op_->mmap_file(map_optiont);
            if (ret != TFS_SUCCESS)
            {
                return ret;
            }
            
            is_load_ = true;

            if (debug)
            {
                printf("init blockid: %d, index successful.data file size: %d, index file size: %d, bucket_size: %d, free head offset: %d, seqno: %d, size: %d, filecount: %d, del_size: %d, del_file_count: %d, version: %d\n", 
                logic_block_id, index_header()->data_file_offset_, index_header()->index_file_size_,
                index_header()->bucket_size_, index_header()->free_head_offset_, block_info()->seq_no_, block_info()->size_,
                block_info()->file_count_, block_info()->del_size_, block_info()->del_file_count_, block_info()->version_);
            }

            return TFS_SUCCESS;
        }


        int IndexHandle::load(const uint32_t logic_block_id, const int32_t _bucket_size, const MMapOption map_option)
        {
            int ret = TFS_SUCCESS;

            if (is_load_)
            {
                return EXIT_INDEX_ALREADY_LOADED_ERROR;
            }

            int64_t file_size = file_op_->get_file_size();
            if (file_size < 0)
            {
                return file_size;
            }
            else if (file_size == 0) /* empty file */
            {
                return EXIT_INDEX_CORRUPT_ERROR;
            }

            MMapOption tmp_map_option = map_option;

            if (file_size > tmp_map_option.first_mmap_size_ && file_size <= tmp_map_option.max_mmap_size_)
            {
                tmp_map_option.first_mmap_size_ = file_size;
            }

            ret = file_op_->mmap_file(tmp_map_option);

            if (ret != TFS_SUCCESS)
            {
                return ret;
            }

            if (debug)
            {
                printf("InexHandle::load - bucket size(): %d, index_header()->bucket_size_: %d, block id: %d \n", bucket_size(), index_header()->bucket_size_, block_info()->block_id_);
            }

            if (0 == bucket_size() || 0 == block_info()->block_id_)
            {
                fprintf(stderr, "lndex corrupt error. blockid: %u, bucket size: %d\n", block_info()->block_id_, bucket_size());
                return EXIT_INDEX_CORRUPT_ERROR;
            }

            /* check file size */
            int32_t index_file_size = sizeof(IndexHandle) + bucket_size() * sizeof(int32_t);

            if (file_size < index_file_size)
            {
                fprintf(stderr, "Index corrupt error. blockid: %u, buck size: %d, file size: %ld, index file size: %d\n", block_info()->block_id_, bucket_size(), file_size, index_file_size);
                return EXIT_INDEX_CORRUPT_ERROR;
            }

            /* check block_id_ size */
            if (logic_block_id != block_info()->block_id_)
            {
                fprintf(stderr, "block id conflict. blockid: %u, index blockid: %u\n", logic_block_id, block_info()->block_id_);
                return EXIT_BLOCKID_CONFLICT_ERROR;
            }

            /* check bucket_size */
            if (_bucket_size != bucket_size())
            {
                fprintf(stderr, "Index configure error, old bucket size: %d, new bucket size: %d\n", bucket_size(), _bucket_size);
                return EXIT_BUCKET_CONFIGURE_ERROR;
            }

            is_load_ = true;

            if (debug)
            {
                printf("load blockid: %d, index successful.data file size: %d, index file size: %d, bucket_size: %d, free head offset: %d, seqno: %d, size: %d, filecount: %d, del_size: %d, del_file_count: %d, version: %d\n", 
                logic_block_id, index_header()->data_file_offset_, index_header()->index_file_size_,
                index_header()->bucket_size_, index_header()->free_head_offset_, block_info()->seq_no_, block_info()->size_,
                block_info()->file_count_, block_info()->del_size_, block_info()->del_file_count_, block_info()->version_);
            }

            return TFS_SUCCESS;
        }


        int IndexHandle::remove(const uint32_t logic_block_id)
        {
            if (is_load_)
            {
                if (logic_block_id != block_info()->block_id_)
                {
                    fprintf(stderr, "block id conflict bolckid: %d, index biokid: %d\n", logic_block_id, block_info()->block_id_);
                    return EXIT_BLOCKID_CONFLICT_ERROR;
                }
            }
            
            int ret = file_op_->munmap_file();
            if (TFS_SUCCESS != ret)
            {
                return ret;
            }

            ret = file_op_->unlink_file();
            return ret;
        }


        int IndexHandle::flush()
        {
            int ret = file_op_->flush_file();

            if (TFS_SUCCESS != ret)
            {
                fprintf(stderr, "index flush fail, ret: %d error desc: %s\n", ret, strerror(errno));
            }

            return ret;
        }


         int IndexHandle::write_segment_meta(const uint64_t key, Metalnfo &meta)
         {
            int32_t current_offset = 0, previous_offset = 0;

            /* 思考? key 存在吗? 存在 => 处理? 不存在 => 处理? */
            /* 1. 从文件哈希表中查找 key 是否存在. hash_find(key, current_offset, previous_offset */
            int ret = hash_find(key, current_offset, previous_offset);
            if (TFS_SUCCESS == ret)
            {
                return EXIT_META_UNEXPECT_FOUND_ERROR;
            }else if (EXIT_META_NOT_FOUND_ERROR == ret)
            {
                return ret;
            }

            /* 2. 不存在就写入 meta 到文件哈希表中 hash_insert(key, previous_offset, meta) */
            ret = hash_insert(key, previous_offset, meta);
            return ret;

         }


         int32_t IndexHandle::read_segment_meta(const uint64_t key, Metalnfo &meta)
         {
            int32_t current_offset = 0, previous_offset = 0;

            /* 1. 确定 key 存放的桶(slot)的位置 */
            //int32_t slot = static_cast<uint32_t>(key) % bucket_size();

            int32_t ret = hash_find(key, current_offset, previous_offset);

            if (ret == TFS_SUCCESS) /* exist */
            {
                ret = file_op_->pread_file(reinterpret_cast<char *>(&meta), sizeof(Metalnfo), current_offset);
                return ret;
            }
            else
            {
                return ret;
            }
            
         }


         int32_t IndexHandle::delete_segment_meta(const uint64_t key) /* 删除 */
         {
            int32_t current_offset = 0, previous_offset = 0;

            int32_t ret = hash_find(key, current_offset, previous_offset);
            if (ret != TFS_SUCCESS)
            {
                return ret;
            }

            Metalnfo meta_info;

            ret = file_op_->pread_file(reinterpret_cast<char *>(&meta_info), sizeof(Metalnfo), current_offset);
            if (ret != TFS_SUCCESS)
            {
                return ret;
            }

            int32_t next_pos = meta_info.get_next_meta_offset();

            if (previous_offset == 0)
            {
                int32_t slot = static_cast<uint32_t>(key) % bucket_size();
                bucket_slot()[slot] = next_pos;
            }
            else
            {
                Metalnfo pre_meta_info;
                ret = file_op_->pread_file(reinterpret_cast<char *>(&pre_meta_info), sizeof(Metalnfo), previous_offset);
                if (ret != TFS_SUCCESS)
                {
                    return ret;
                }

                pre_meta_info.set_next_meta_offset(next_pos);

                ret = file_op_->pwrite_file(reinterpret_cast<char *>(&pre_meta_info), sizeof(Metalnfo), previous_offset);
                if (ret != TFS_SUCCESS)
                {
                    return ret;
                }
            }

            /* 把删除节点加入可重用节点链表(下一个小节实现) */
            meta_info.set_next_meta_offset(free_head_offset()); /* index_header()->free_head_offset_ */
            ret = file_op_->pwrite_file(reinterpret_cast<char *>(&meta_info), sizeof(Metalnfo), current_offset);
            if (ret != TFS_SUCCESS)
            {
                return ret;
            }

            index_header()->free_head_offset_ = current_offset;
            if (debug) 
            {
                printf("delete_segment_meta - reuse metainfo current_offset: %d\n", current_offset);
            }

            update_block_info(C_OPER_DELETE, meta_info.get_size());
            return TFS_SUCCESS;
         }


         int IndexHandle::hash_find(const uint64_t key, int32_t &current_offset, int32_t &previous_offset)
         {
            int ret = TFS_SUCCESS;
            Metalnfo meta_info;

            current_offset = 0;
            previous_offset = 0;

            /* 1. 确定 key 存放的桶(slot)的位置 */
            int32_t slot = (int32_t)key % bucket_size();

            /* 2. 读取桶首节点存储的第一个节点的偏移量, 如果偏移量为零, 直接返回 EXIT_META_NOT_FOUND_ERROR */
            /* 3. 根据偏移量读取存储的metainfo */
            /* 4. 与key进行比较, 相等则设置 current_offset 和 previous_offset 并返回 TFS_SUCCESS, 否则继续执行5 */
            /* 5. 从 metainfo 中取得下一个节点的在文件中的偏移量, 如果偏移量为零, 直接返回 EXIT_META_NOT_FOUND_ERROR,
            否则继续跳转到3循环执行 */
            int32_t pos = bucket_slot()[slot];

            for (; pos != 0; )
            {
                ret = file_op_->pread_file(reinterpret_cast<char *>(&meta_info), sizeof(Metalnfo), pos);
                if (TFS_SUCCESS != ret)
                {
                    return ret;
                }

                if (hash_compare(key, meta_info.get_key()))
                {
                    current_offset = pos;
                    return TFS_SUCCESS;
                }

                previous_offset = pos;
                pos = meta_info.get_next_meta_offset();
            }

            return EXIT_META_NOT_FOUND_ERROR;
        }


        int32_t IndexHandle::hash_insert(const uint64_t key, int32_t previous_offset, Metalnfo &meta)
        {
            Metalnfo tmp_meta_info;
            int ret = TFS_SUCCESS;
            int32_t current_offset = 0;

            /* 1. 确定 key 存放的桶(slot)的位置 */
            int32_t slot = static_cast<uint32_t>(key) % bucket_size();

            /* 2. 确定 meta 节点存储中文件中的偏移量 */
            if (free_head_offset() != 0)
            {
                ret = file_op_->pread_file(reinterpret_cast<char *>(&tmp_meta_info), sizeof(Metalnfo), free_head_offset());
                if (ret != TFS_SUCCESS)
                {
                    return ret;
                }

                current_offset = index_header()->free_head_offset_;
                if (debug) 
                {
                    printf("reuse metainfo current_offset: %d\n", current_offset);
                }
                index_header()->free_head_offset_ = tmp_meta_info.get_next_meta_offset();
            }
            else
            {
                current_offset = index_header()->index_file_size_;
                index_header()->index_file_size_ += sizeof(Metalnfo);
            }
            

            /* 3. 将 meta 节点写入索引文件中 */
            meta.set_next_meta_offset(0); /* 我怀疑我忘了实现 */

            ret = file_op_->pwrite_file(reinterpret_cast<const char *>(&meta), sizeof(Metalnfo), current_offset);
            if (ret != TFS_SUCCESS)
            {
                index_header()->index_file_size_ -= sizeof(Metalnfo);
                return ret;
            }

            /* 4. 将 meta 节点插入到哈希链表中 */
            /* 当前一个节点已经存在 */
            if (0 != previous_offset)
            {
                ret = file_op_->pread_file(reinterpret_cast<char *>(&tmp_meta_info), sizeof(Metalnfo), previous_offset);
                if (TFS_SUCCESS != ret)
                {
                    index_header()->index_file_size_ -= sizeof(Metalnfo);
                    return ret;
                }

                tmp_meta_info.set_next_meta_offset(current_offset);
                ret = file_op_->pwrite_file(reinterpret_cast<const char *>(&tmp_meta_info), sizeof(Metalnfo), previous_offset);
                if (TFS_SUCCESS != ret)
                {
                    index_header()->index_file_size_ -= sizeof(Metalnfo);
                    return ret;
                }
            }
            else /* 不存在前一个节点的情况 */
            {
                bucket_slot()[slot] = current_offset;
            }
            
            return TFS_SUCCESS;
        }


        int IndexHandle::update_block_info(const OperType oper_type, const uint32_t modify_size) /* 更新块信息 */
        {
            if (block_info()->block_id_ == 0)
            {
                return EXIT_BLOCKID_ZERO_ERROR;
            }

            if (oper_type == C_OPER_INSERT)
            {
                ++block_info()->version_;
                ++block_info()->file_count_;
                ++block_info()->seq_no_;
                block_info()->size_ += modify_size;
            }
            else if (oper_type == C_OPER_DELETE)
            {
                ++block_info()->version_;
                --block_info()->file_count_;
                block_info()->size_ -= modify_size;
                ++block_info()->del_file_count_;
                block_info()->del_size_ += modify_size;
            }

            if (debug)
            {
                printf("updata block info. blockid: %u, version: %u, file count: %u, size: %u, del file count: %u, del size: %u, seq no: %u, oper type: %d\n", 
                block_info()->block_id_, block_info()->version_, block_info()->file_count_, block_info()->size_,
                block_info()->del_file_count_, block_info()->del_size_, block_info()->seq_no_, oper_type);
            }

            return TFS_SUCCESS;
        }
    }
}

编译:

g++ block_delete_test.cpp file_op.cpp index_handle.cpp mmap_file.cpp  mmap_file_op.cpp -o block_delete_test

执行:

(我人傻了, 可能手抖或走神写错代码, 完全测试失败! 别问我错误原因, 我不知道, 因为这代码是别人的思想, 不过没有关系, 第一轮我也是有目的的-- 就是看到思想, 和为啥它这么写, 第二轮复习再来, 我觉得就没问题)
在这里插入图片描述

结束 - 文件系统核心存储引擎

结语:

总之: 第一轮了解它的思想, 编程的核心就是思想 - > 再实现

最后上传老师的代码如下:

https://download.csdn.net/download/m0_45867846/12564372

时间: 2020-06-30

weifc-wei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jbpm-demo-master.zip_DEMO_activiti-master_jbpm-demo_mean3x7
09-21
在jbpm-demo或activiti-master中集成MEAN，意味着这些工作流示例可能展示了如何将流程引擎与现代Web应用框架相结合，实现数据存储、API处理、用户界面交互等功能。 jbpm-demo-master作为压缩包中的一个子目录，可能...
kft-activiti-demo-master_tapepju_palaces66_DEMO_activiti_
09-30
- Repository Service：存储和检索流程定义（BPMN 2.0 XML文件）。 - Runtime Service：处理流程实例的生命周期，如启动、暂停、恢复和结束。 - Task Service：处理任务分配、完成和查询。 - History Service：...
文件系统核心存储引擎_实现(二)
weifc-wei 的博客
06-20 183
内存映射实战之文件操作父类头文件定义
g++编译详解
热门推荐
Three_dog的博客
12-24 4万+
g++编译详解 资料准备： 为了方便演示和讲解，在这里提前准备好几个简单的文件：test.cpp test.h main.cpp 文件内容如下： main.cpp //main.cpp int main (int argc, char **argv) { return 0; } test.h //test.h #ifndef _TEST_H_ #define _TEST_H_ ...
文件系统核心存储引擎_实现(四)
weifc-wei 的博客
06-27 253
顶顶顶顶
【转载】缓冲处理器 buffer handle 的内部机制
cuituo5185的博客
02-09 331
　　很多DBA在评价数据库的性能时都花费一定的时间查看logical I/O，并将logical I/O作为CPU消耗的粗略指示。通常这是有道理的，但是由于某些原因有一定的误差。　　一个重要的错误是Oracle可以通过不用执行l...
OpenHarmony编译构建系统详解，从零搭建windows下开发环境，巨方便！
一口Linux的专栏
07-26 4659
自从OpenHarmony更新了dev-tool，就可以在windows下构建鸿蒙（轻量型）系统了，这对于进行MCU开发的朋友们，学习鸿蒙OS会友好许多！我们可以更快的构建出系统，方便快速学习和验证。不过关于这个开发环境搭建的文章，网上比较少，而且坑也很多。所以这篇文章，我就带大家从零完成dev-tool的环境搭建，帮大家降低学习OpenHarmony的学习成本！ 我们先讲一下OpenHarmony的编译构建框架，当大家理解了这个框架后，再学习环境的搭建和工程开发，心里会有底气许多。 一、穿针引线-编译构建
CH-8.6---PageRank.rar_Java 8
09-24
6. **结果输出**：最终的PageRank值会被写入到文件系统中，可以用于后续的查询和分析。 Java 8在这个过程中提供了一些便利，例如`Stream` API可以用来更方便地处理数据，提高代码的简洁性和可读性。此外，Java 8的...
Nero-SDK.rar_Nero_nero sdk_刻录
09-24
7. **光盘格式和标准**：刻录过程中需要理解不同类型的光盘格式，如CD-R/RW、DVD-R/RW、Blu-ray等，以及相关的文件系统标准，如ISO 9660、UDF等。 8. **日志记录和调试**：为了追踪和调试可能出现的问题，开发者...
商业编程-源码-音频技术源代码 MidiPlayer_src.zip
06-24
MIDI消息包括音符开始、音符结束、控制器改变（如音量、颤音等）和系统全局信息。与普通的音频文件不同，MIDI文件不存储声音样本，而是存储指令序列，这些指令告诉设备何时以及如何演奏音符。 MidiPlayer_src项目中...
【鸿蒙设备开发笔记】OpenHarmony源码目录介绍+编译框架介绍
GuanFuXinCSDN的博客
08-22 7209
目录【鸿蒙设备开发笔记】OpenHarmony源码目录介绍+编译框架介绍源码目录编译框架Json文件模块编译构造文件 .gn文件业务编译构造文件 .gn文件 【鸿蒙设备开发笔记】OpenHarmony源码目录介绍+编译框架介绍 源码目录 以小熊派为例子，其他开发板也不会差很多 小熊派的源码目录延续OpenHarmony官方目录结构，以下是源码目录的说明： 目录名 描述 applications BearPi-HM_Nano应用程序样例 base 基础软件服务子系统集&硬件服务子
文件系统核心存储引擎_文件存储的基本单位-块
weifc-wei 的博客
06-14 852
文件存储的基本单位 块 － 文件存取的最小单位。"块"的大小，最常见的是4KB，即连续八个 sector组成一个 block。 下面这是为了好看一点 举个例子 使用touch命令新建一个文件。 touch demo.txt 查看具体信息 ls -la linux中的echo命令bai，功能是在显示du器上显示一段文字，一般起到一个zhi提示的作用。echo会将dao输入的字符串送往标准输出。输出的字符串间以空白字符隔开, 并在最后加上换行号。 echo '1' > demo.txt 简单的
20220319编译OpenHarmony-v3.1-beta出错的解决方法
南岭笑笑生之家
03-25 5894
20220319编译OpenHarmony-v3.1-beta出错的解决方法 2022/3/19 14:29 【结论】：华为的做事也太不认真了！^_你的压缩包都没有给完整的，还好我做过的！ （程序文本都是齐全的，第二步获取二进制文件没有做！） 不然新手查找问题，会找的你怀疑人生的！ 1、下载OpenHarmony-v3.1-beta并编译： https://gitee.com/openharmony OpenHarmony开源项目 https://gitee.com/openharmon
对OpenHarmony中LiteOS的内核分析——超时原理和应用
OpenHarmony_dev的博客
07-11 483
在软件世界里面，超时是一个非常重要的概念。比如● 当前线程暂时休眠1秒钟，休眠结束后继续执行● 每5秒钟采集一下CPU利用率● 数据发送失败，2秒钟以后再试一试● 等待某种数据，但最多等待50毫秒//将当前任务休眠若干tick数，tick为时间单位，常见值为10毫秒LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)//获取信号量semHandle, 如果当前信号量不可用且timeout不为0，则最多等待timeout所指定的时间，在这段时间内如果信号量可用，
索引处理类的设计与实现
木子皿--啥都不会的菜鸟
07-06 1695
文章目录1 索引处理类的头文件定义 1 索引处理类的头文件定义 #ifndef QINIU_LARGEFILE_INDEX_HANDLE_H_ #define QINIU_LARGEFILE_INDEX_HANDLE_H_ #include "common.h" #include "mmap_file_op.h" namespace qiniu { namespace largefile { struct IndexHeader { public: IndexHeade
C++(11)类语法分析(2)
Once_day的回忆
08-17 1229
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C++匿名函数lamba简介
yao_tao11的博客
08-18 671
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 613
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C语言——函数递归
2406_83392683的博客
08-18 406
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
"Flowable流程引擎核心表分析及历史发展
综上所述，flowable流程引擎的核心表设计规范化、系统化，并提供了丰富的数据访问和操作接口，使开发人员可以更轻松地管理和控制流程的运行。这些核心表的设计不仅能够满足引擎的运行需要，还能够方便地支持流程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值