C++ stripedio::managed_malloc方法代码示例

        // TODO: recycle ptr!
        void load() {
            is_loaded = true;
            adjfilesize = get_filesize(filename_adj);
            edatafilesize = get_filesize(filename_edata);
            
            bool async_inedgedata_loading = !svertex_t().computational_edges();
            
#ifdef SUPPORT_DELETIONS
            async_inedgedata_loading = false;  // Currently we encode the deleted status of an edge into the edge value (should be changed!),
                                               // so we need the edge data while loading
#endif
                        
            //preada(adjf, adjdata, adjfilesize, 0);
            
            adj_session = iomgr->open_session(filename_adj, true);
            iomgr->managed_malloc(adj_session, &adjdata, adjfilesize, 0);
            adj_stream_session = streaming_task(iomgr, adj_session, adjfilesize, (char**) &adjdata);
            
            iomgr->launch_stream_reader(&adj_stream_session);            
            /* Initialize edge data asynchonous reading */
            if (!only_adjacency) {
                edata_iosession = iomgr->open_session(filename_edata, false);
                
                iomgr->managed_malloc(edata_iosession, &edgedata, edatafilesize, 0);
                if (async_inedgedata_loading) {
                    iomgr->managed_preada_async(edata_iosession, &edgedata, edatafilesize, 0);
                } else {
                    iomgr->managed_preada_now(edata_iosession, &edgedata, edatafilesize, 0);
                }
            }
        }

 inline void check_curblock(size_t toread) {
     if (curblock == NULL || curblock->end < edataoffset+toread) {
         if (curblock != NULL) {
             if (!curblock->active) {
                 curblock->release(iomgr);
             }
         }
         // Load next
         std::string blockfilename = filename_shard_edata_block(filename_edata, (int) (edataoffset / blocksize), blocksize);
         int edata_session = iomgr->open_session(blockfilename, false, true);
         sblock<ET> newblock(edata_session, edata_session, true, blockfilename);
         
         // We align blocks always to the blocksize, even if that requires
         // allocating and reading some unnecessary data.
         newblock.offset = (edataoffset / blocksize) * blocksize; // Align
         size_t correction = edataoffset - newblock.offset;
         newblock.end = std::min(edatafilesize, newblock.offset + blocksize);
         assert(newblock.end >= newblock.offset);
         int realsize = get_block_uncompressed_size(blockfilename, newblock.end - newblock.offset);
         iomgr->managed_malloc(edata_session, &newblock.data, realsize, newblock.offset);
         newblock.ptr = newblock.data + correction;
         activeblocks.push_back(newblock);
         curblock = &activeblocks[activeblocks.size()-1];
         curblock->active = true;
         curblock->read_now(iomgr);
     }
 }

 vdblock load_block(int blockid) {
     vdblock db(blockid);
     
     std::string blockfname = blockfilename(blockid);
     db.fd = iomgr->open_session(blockfname, false, true);
     int realsize = get_block_uncompressed_size(blockfname, -1);
     assert(realsize > 0);
     
     iomgr->managed_malloc(db.fd, &db.data, realsize, 0);
     iomgr->managed_preada_now(db.fd, &db.data, realsize, 0);
     db.dblock = new dynamicdata_block<VertexDataType>(verticesperblock, (uint8_t *)db.data, realsize);
     return db;
 }

 /**
   * Loads a chunk of vertex degrees
   * @param vertex_st first vertex id
   * @param vertex_en last vertex id, inclusive
   */
 virtual void load(vid_t _vertex_st, vid_t _vertex_en) {
     assert(_vertex_en >= _vertex_st);
     vertex_st = _vertex_st;
     vertex_en = _vertex_en;
     
     size_t datasize = (vertex_en - vertex_st + 1) * sizeof(degree);
     size_t datastart = vertex_st * sizeof(degree);
     
     if (loaded_chunk != NULL) {
         iomgr->managed_release(filedesc, &loaded_chunk);
     }
     
     iomgr->managed_malloc(filedesc, &loaded_chunk, datasize, datastart);
     iomgr->managed_preada_now(filedesc, &loaded_chunk, datasize, datastart);
 }

        /**
         * Loads a chunk of vertex values
         * @param vertex_st first vertex id
         * @param vertex_en last vertex id, inclusive
         */
        virtual void load(vid_t _vertex_st, vid_t _vertex_en) {
            if (!use_mmap) {
                assert(_vertex_en >= _vertex_st);
                vertex_st = _vertex_st;
                vertex_en = _vertex_en;
                
                size_t datasize = (vertex_en - vertex_st + 1)* sizeof(VertexDataType);
                size_t datastart = vertex_st * sizeof(VertexDataType);
                
                if (loaded_chunk != NULL) {
                    iomgr->managed_release(filedesc, &loaded_chunk);
                }
                
                iomgr->managed_malloc(filedesc, &loaded_chunk, datasize, datastart);
                iomgr->managed_preada_now(filedesc, &loaded_chunk, datasize, datastart);
            } else {
                // Do nothing
            }

        }

 inline void check_adjblock(size_t toread) {
     if (curadjblock == NULL || curadjblock->end <= adjoffset + toread) {
         if (curadjblock != NULL) {
             curadjblock->release(iomgr);
             delete curadjblock;
             curadjblock = NULL;
         }
         sblock<ET> * newblock = new sblock<ET>(0, adjfile_session);
         newblock->offset = adjoffset;
         newblock->end = std::min(adjfilesize, adjoffset+blocksize);
         assert(newblock->end > 0);
         assert(newblock->end >= newblock->offset);
         iomgr->managed_malloc(adjfile_session, &newblock->data, newblock->end - newblock->offset, adjoffset);
         newblock->ptr = newblock->data;
         metrics_entry me = m.start_time();
         iomgr->managed_preada_now(adjfile_session, &newblock->data, newblock->end - newblock->offset, adjoffset);
         m.stop_time(me, "blockload");
         curadjblock = newblock;
     }
 }