hadoop单个数据节点的不同存储路径的存储策略源码分析

最新推荐文章于 2021-12-22 08:25:11 发布
最新推荐文章于 2021-12-22 08:25:11 发布
阅读量1.6k 收藏
点赞数
分类专栏： 大数据

hadoop单个数据节点的不同存储路径的存储策略源码分析。

来源：IT165收集  发布日期：2014-09-01 20:52:50
我来说两句(0) 收藏本文
-
id="starIframe1" height="90" marginheight="0" src="http://inte.sogou.com/ct?ssi0=257&pvt=1436765347687&t2=1436765348&t1=0&bi=1&lan=zh-cn&ece=true&nmi=0&npl=0&eja=true&lhi=1&ccd=32&srp=1920,1080&bs=1012,544&lmt=1411136798&z=f9548647fdf32be6&rnd=fab635121e99e884&ti=hadoop%E5%8D%95%E4%B8%AA%E6%95%B0%E6%8D%AE%E8%8A%82%E7%82%B9%E7%9A%84%E4%B8%8D%E5%90%8C%E5%AD%98%E5%82%A8%E8%B7%AF%E5%BE%84%E7%9A%84%E5%AD%98%E5%82%A8%E7%AD%96%E7%95%A5%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E3%80%82%20-%20%E6%9C%8D%E5%8A%A1%E5%99%A8%E6%8A%80%E6%9C%AF%E7%BB%BC%E5%90%88%20-%20%E6%AC%A1%E5%85%83%E7%AB%8B%E6%96%B9%E7%BD%91%20-%20%E7%94%B5%E8%84%91%E7%9F%A5%E8%AF%86%E4%B8%8E%E6%8A%80%E6%9C%AF%E4%BA%92%E5%8A%A8%E4%BA%A4&refer=http%3A%2F%2Fwww.baidu.com%2Flink%3Furl%3Dv09KXndGxChD_u2QPWFBCCxxIaIY4D3sENdg4v4dQ6hcYm9uUS-5wcsxUVdYBngKlhtLn6LGqO2j5rd_o9CRmK%26wd%3D%26eqid%3Db42b72950000c2bb0000000455a34c87&sohuurl=http%3A%2F%2Fwww.it165.net%2Fadmin%2Fhtml%2F201409%2F3635.html&if=16&fv=18&w=728&h=90&id=254473&tmp_cdif=0&mi=0&m=MTQzNjc2NTM1OV9wcmV0dHkgZG9nXzI1NDQ3MwA-&ex=" frameborder="0" width="728" allowtransparency="" marginwidth="0" scrolling="no" align="center,center">

  • 产生问题于数据集群的数节点存储磁盘大小不同，造成使用一段时间以后容量小的磁盘空间紧张。

    其实，早期配置了磁盘使用存储策略，就能解决该问题，部分网来上说这个策略无效，再hadoop2.0.1 本版有效，该版本应用于CHD4.6中。

    为了找到准确的程序定位点，参考了以下的Hadoop设计文档。

    参考

    Hadoop中HDFS文件系统的Append/Hflush/Read设计文档：

    http://blog.csdn.net/chenpingbupt/article/details/7972589

    文档中给出：

    在一个DN的disk中，每个DN具有三个目录:current em bw，current包含finallized的replica，tmp包含temporary replica，rbw包含rbw，rwr，rur replicas。当一个replica第一次被dfs client发起请求而创建的时候，将会放到rbw中。当第一次创建是在block replication和clust balance过程中发起的话，replica就会放置到tmp中。一旦一个replica被finallized，他就会被move到current中。当一个DN重启之后，tmp中的replica将会被删除，rbw中的将会被加载为rwr状态，current中的会load为finallized状态

    我们就从tmp 或 rbw 文件创建开始。

    1.参见java class BlockPoolSlice

     

    view source print ?
    01. /**
    02.  * A block pool slice represents a portion of a block pool stored on a volume.  
    03.  * Taken together, all BlockPoolSlices sharing a block pool ID across a 
    04.  * cluster represent a single block pool.
    05.  * 
    06.  * This class is synchronized by {@link FsVolumeImpl}.
    07.  */
    08. class BlockPoolSlice {
    09.   private final String bpid;
    10.   private final FsVolumeImpl volume; // volume to which this BlockPool belongs to
    11.   private final File currentDir; // StorageDirectory/current/bpid/current
    12.   private final LDir finalizedDir; // directory store Finalized replica
    13.   private final File rbwDir; // directory store RBW replica
    14.   private final File tmpDir; // directory store Temporary replica

    从类的描述中看出BlockPoolSlice 是创建集群数据block的基础。

     

     

    view source print ?
    01. /**
    02.    * Temporary files. They get moved to the finalized block directory when
    03.    * the block is finalized.
    04.    */
    05.   File createTmpFile(Block b) throws IOException {
    06.     File f = new File(tmpDir, b.getBlockName());
    07.     return DatanodeUtil.createTmpFile(b, f);
    08.   }
    09.   
    10.   /**
    11.    * RBW files. They get moved to the finalized block directory when
    12.    * the block is finalized.
    13.    */
    14.   File createRbwFile(Block b) throws IOException {
    15.     File f = new File(rbwDir, b.getBlockName());
    16.     return DatanodeUtil.createTmpFile(b, f);
    17.   }
    这是创建基础文件的方法。

     


    2.该方法的实现

     

    view source print ?
    01. /** Provide utility methods for Datanode. */
    02. @InterfaceAudience.Private
    03. public class DatanodeUtil {
    04.   public static final String UNLINK_BLOCK_SUFFIX = ".unlinked";
    05.   
    06.   public static final String DISK_ERROR = "Possible disk error: ";
    07.   
    08.   /** Get the cause of an I/O exception if caused by a possible disk error
    09.    * @param ioe an I/O exception
    10.    * @return cause if the I/O exception is caused by a possible disk error;
    11.    *         null otherwise.
    12.    */ 
    13.   static IOException getCauseIfDiskError(IOException ioe) {
    14.     if (ioe.getMessage()!=null && ioe.getMessage().startsWith(DISK_ERROR)) {
    15.       return (IOException)ioe.getCause();
    16.     } else {
    17.       return null;
    18.     }
    19.   }
    20.   
    21.   /**
    22.    * Create a new file.
    23.    * @throws IOException 
    24.    * if the file already exists or if the file cannot be created.
    25.    */
    26.   public static File createTmpFile(Block b, File f) throws IOException {
    27.     if (f.exists()) {
    28.       throw new IOException("Failed to create temporary file for " + b
    29.           + ".  File " + f + " should not be present, but is.");
    30.     }
    31.     // Create the zero-length temp file
    32.     final boolean fileCreated;
    33.     try {
    34.       fileCreated = f.createNewFile();
    35.     } catch (IOException ioe) {
    36.       throw new IOException(DISK_ERROR + "Failed to create " + f, ioe);
    37.     }
    38.     if (!fileCreated) {
    39.       throw new IOException("Failed to create temporary file for " + b
    40.           + ".  File " + f + " should be creatable, but is already present.");
    41.     }
    42.     return f;
    43.   }

     

    在调用该方法创建数据block时，并没有我们关心的存储路径的选择策略。

    3.我们再来查找createRbwFile调用出处

     

    view source print ?
    1. /**************************************************
    2.  * FSDataset manages a set of data blocks.  Each block
    3.  * has a unique name and an extent on disk.
    4.  *
    5.  ***************************************************/
    6. @InterfaceAudience.Private
    7. class FsDatasetImpl implements FsDatasetSpi<FsVolumeImpl> {
    8.   static final Log LOG = LogFactory.getLog(FsDatasetImpl.class);
    block管理操作类

     

     

    view source print ?
    01. @Override // FsDatasetSpi
    02.   public synchronized ReplicaInPipeline createRbw(ExtendedBlock b)
    03.       throws IOException {
    04.     ReplicaInfo replicaInfo = volumeMap.get(b.getBlockPoolId(), 
    05.         b.getBlockId());
    06.     if (replicaInfo != null) {
    07.       throw new ReplicaAlreadyExistsException("Block " + b +
    08.       " already exists in state " + replicaInfo.getState() +
    09.       " and thus cannot be created.");
    10.     }
    11.     // create a new block
    12.     FsVolumeImpl v = volumes.getNextVolume(b.getNumBytes());
    13.     // create a rbw file to hold block in the designated volume
    14.     File f = v.createRbwFile(b.getBlockPoolId(), b.getLocalBlock());
    15.     ReplicaBeingWritten newReplicaInfo = new ReplicaBeingWritten(b.getBlockId(), 
    16.         b.getGenerationStamp(), v, f.getParentFile());
    17.     volumeMap.add(b.getBlockPoolId(), newReplicaInfo);
    18.     return newReplicaInfo;
    19.   }
    调用了createRbwFile 方法，该方法同样创建rbw文件。

     

    这里发现了我们关系的volumes，它是配置的存储路径。

    4.查看volumes 的初始

    volumnes是在构造函数中初始化的，使用了volArray

     

    view source print ?
    01. /**
    02.    * An FSDataset has a directory where it loads its data files.
    03.    */
    04.   FsDatasetImpl(DataNode datanode, DataStorage storage, Configuration conf
    05.       ) throws IOException {
    06.     this.datanode = datanode;
    07.     // The number of volumes required for operation is the total number 
    08.     // of volumes minus the number of failed volumes we can tolerate.
    09.     final int volFailuresTolerated =
    10.       conf.getInt(DFSConfigKeys.DFS_DATANODE_FAILED_VOLUMES_TOLERATED_KEY,
    11.                   DFSConfigKeys.DFS_DATANODE_FAILED_VOLUMES_TOLERATED_DEFAULT);
    12.   
    13.     String[] dataDirs = conf.getTrimmedStrings(DFSConfigKeys.DFS_DATANODE_DATA_DIR_KEY);
    14.   
    15.     int volsConfigured = (dataDirs == null) ? 0 : dataDirs.length;
    16.     int volsFailed = volsConfigured - storage.getNumStorageDirs();
    17.     this.validVolsRequired = volsConfigured - volFailuresTolerated;
    18.   
    19.     if (volFailuresTolerated < 0 || volFailuresTolerated >= volsConfigured) {
    20.       throw new DiskErrorException("Invalid volume failure "
    21.           + " config value: " + volFailuresTolerated);
    22.     }
    23.     if (volsFailed > volFailuresTolerated) {
    24.       throw new DiskErrorException("Too many failed volumes - "
    25.           + "current valid volumes: " + storage.getNumStorageDirs() 
    26.           + ", volumes configured: " + volsConfigured 
    27.           + ", volumes failed: " + volsFailed
    28.           + ", volume failures tolerated: " + volFailuresTolerated);
    29.     }
    30.   
    31.     final List<FsVolumeImpl> volArray = new ArrayList<FsVolumeImpl>(
    32.         storage.getNumStorageDirs());
    33.     for (int idx = 0; idx < storage.getNumStorageDirs(); idx++) {
    34.       final File dir = storage.getStorageDir(idx).getCurrentDir();
    35.       volArray.add(new FsVolumeImpl(this, storage.getStorageID(), dir, conf));
    36.       LOG.info("Added volume - " + dir);
    37.     }
    38.     volumeMap = new ReplicaMap(this);
    39.   
    40.     @SuppressWarnings("unchecked")
    41.     final VolumeChoosingPolicy<FsVolumeImpl> blockChooserImpl =
    42.         ReflectionUtils.newInstance(conf.getClass(
    43.             DFSConfigKeys.DFS_DATANODE_FSDATASET_VOLUME_CHOOSING_POLICY_KEY,
    44.             RoundRobinVolumeChoosingPolicy.class,
    45.             VolumeChoosingPolicy.class), conf);
    46.     volumes = new FsVolumeList(volArray, volsFailed, blockChooserImpl);
    47.     volumes.getVolumeMap(volumeMap);
    48.   
    49.     File[] roots = new File[storage.getNumStorageDirs()];
    50.     for (int idx = 0; idx < storage.getNumStorageDirs(); idx++) {
    51.       roots[idx] = storage.getStorageDir(idx).getCurrentDir();
    52.     }
    53.     asyncDiskService = new FsDatasetAsyncDiskService(datanode, roots);
    54.     registerMBean(storage.getStorageID());
    55.   }
    而volArray 如下生成的：

     

     

    view source print ?
    1. final List<FsVolumeImpl> volArray = new ArrayList<FsVolumeImpl>(
    2.         storage.getNumStorageDirs());
    3.     for (int idx = 0; idx < storage.getNumStorageDirs(); idx++) {
    4.       final File dir = storage.getStorageDir(idx).getCurrentDir();
    5.       volArray.add(new FsVolumeImpl(this, storage.getStorageID(), dir, conf));
    6.       LOG.info("Added volume - " + dir);
    7.     }
    正式配置文件中的存储路径。

     

    到此，我们找到了需要的存储路径，下面再找到如何选择的路径的就容易多了。

    5.路径选择从getNextVolume开始

     

    view source print ?
    01. class FsVolumeList {
    02.   /**
    03.    * Read access to this unmodifiable list is not synchronized.
    04.    * This list is replaced on modification holding "this" lock.
    05.    */
    06.   volatile List<FsVolumeImpl> volumes = null;
    07.   
    08.   private final VolumeChoosingPolicy<FsVolumeImpl> blockChooser;
    09.   private volatile int numFailedVolumes;
    10.   
    11.   FsVolumeList(List<FsVolumeImpl> volumes, int failedVols,
    12.       VolumeChoosingPolicy<FsVolumeImpl> blockChooser) {
    13.     this.volumes = Collections.unmodifiableList(volumes);
    14.     this.blockChooser = blockChooser;
    15.     this.numFailedVolumes = failedVols;
    16.   }
    17.     
    18.   int numberOfFailedVolumes() {
    19.     return numFailedVolumes;
    20.   }
    21.     
    22.   /** 
    23.    * Get next volume. Synchronized to ensure {@link #curVolume} is updated
    24.    * by a single thread and next volume is chosen with no concurrent
    25.    * update to {@link #volumes}.
    26.    * @param blockSize free space needed on the volume
    27.    * @return next volume to store the block in.
    28.    */
    29.   synchronized FsVolumeImpl getNextVolume(long blockSize) throws IOException {
    30.     return blockChooser.chooseVolume(volumes, blockSize);
    31.   }

     

    6.继续chooseVolume 源自于 blockChooser 类型是 VolumeChoosingPolicy ，该方法实现在下面的类中：

     

    view source print ?
    01. /**
    02.  * A DN volume choosing policy which takes into account the amount of free
    03.  * space on each of the available volumes when considering where to assign a
    04.  * new replica allocation. By default this policy prefers assigning replicas to
    05.  * those volumes with more available free space, so as to over time balance the
    06.  * available space of all the volumes within a DN.
    07.  */
    08. public class AvailableSpaceVolumeChoosingPolicy<V extends FsVolumeSpi>
    09.     implements VolumeChoosingPolicy<V>, Configurable {
    10.     
    11.   private static final Log LOG = LogFactory.getLog(AvailableSpaceVolumeChoosingPolicy.class);
    12.     
    13.   private static final Random RAND = new Random();
    14.     
    15.   private long balancedSpaceThreshold = DFS_DATANODE_AVAILABLE_SPACE_VOLUME_CHOOSING_POLICY_BALANCED_SPACE_THRESHOLD_DEFAULT;
    16.   private float balancedPreferencePercent = DFS_DATANODE_AVAILABLE_SPACE_VOLUME_CHOOSING_POLICY_BALANCED_SPACE_PREFERENCE_FRACTION_DEFAULT;
    从描述中可以看出了，这就是策略文件。

     

    7.策略实现就是这样的：

     

    view source print ?
    01. @Override
    02.  public synchronized V chooseVolume(List<V> volumes,
    03.      final long replicaSize) throws IOException {
    04.    if (volumes.size() < 1) {
    05.      throw new DiskOutOfSpaceException("No more available volumes");
    06.    }
    07.      
    08.    AvailableSpaceVolumeList volumesWithSpaces =
    09.        new AvailableSpaceVolumeList(volumes);
    10.      
    11.    if (volumesWithSpaces.areAllVolumesWithinFreeSpaceThreshold()) {
    12.      // If they're actually not too far out of whack, fall back on pure round
    13.      // robin.
    14.      V volume = roundRobinPolicyBalanced.chooseVolume(volumes, replicaSize);
    15.      if (LOG.isDebugEnabled()) {
    16.        LOG.debug("All volumes are within the configured free space balance " +
    17.            "threshold. Selecting " + volume + " for write of block size " +
    18.            replicaSize);
    19.      }
    20.      return volume;
    21.    } else {
    22.      V volume = null;
    23.      // If none of the volumes with low free space have enough space for the
    24.      // replica, always try to choose a volume with a lot of free space.
    25.      long mostAvailableAmongLowVolumes = volumesWithSpaces
    26.          .getMostAvailableSpaceAmongVolumesWithLowAvailableSpace();
    27.        
    28.      List<V> highAvailableVolumes = extractVolumesFromPairs(
    29.          volumesWithSpaces.getVolumesWithHighAvailableSpace());
    30.      List<V> lowAvailableVolumes = extractVolumesFromPairs(
    31.          volumesWithSpaces.getVolumesWithLowAvailableSpace());
    32.        
    33.      float preferencePercentScaler =
    34.          (highAvailableVolumes.size() * balancedPreferencePercent) +
    35.          (lowAvailableVolumes.size() * (1 - balancedPreferencePercent));
    36.      float scaledPreferencePercent =
    37.          (highAvailableVolumes.size() * balancedPreferencePercent) /
    38.          preferencePercentScaler;
    39.      if (mostAvailableAmongLowVolumes < replicaSize ||
    40.          RAND.nextFloat() < scaledPreferencePercent) {
    41.        volume = roundRobinPolicyHighAvailable.chooseVolume(
    42.            highAvailableVolumes,
    43.            replicaSize);
    44.        if (LOG.isDebugEnabled()) {
    45.          LOG.debug("Volumes are imbalanced. Selecting " + volume +
    46.              " from high available space volumes for write of block size "
    47.              + replicaSize);
    48.        }
    49.      } else {
    50.        volume = roundRobinPolicyLowAvailable.chooseVolume(
    51.            lowAvailableVolumes,
    52.            replicaSize);
    53.        if (LOG.isDebugEnabled()) {
    54.          LOG.debug("Volumes are imbalanced. Selecting " + volume +
    55.              " from low available space volumes for write of block size "
    56.              + replicaSize);
    57.        }
    58.      }
    59.      return volume;
    60.    }
    61.  }

    关于配置中各个存储路径如何选择及选择策略都在这里了，sigh 累死了～～

     

    花费了接近3天的时间，纯代码看着实累，可以步进就好了。

    相关的配置说明。

    dfs.datanode.fsdataset.volume.choosing.policy

    dfs.datanode.available-space-volume-choosing-policy.balanced-space-threshold

    10737418240

    Only used when the dfs.datanode.fsdataset.volume.choosing.policy is set to org.apache.hadoop.hdfs.server.datanode.fsdataset.AvailableSpaceVolumeChoosingPolicy. This setting controls how much DN volumes are allowed to differ in terms of bytes of free disk space before they are considered imbalanced. If the free space of all the volumes are within this range of each other, the volumes will be considered balanced and block assignments will be done on a pure round robin basis.


    dfs.datanode.available-space-volume-choosing-policy.balanced-space-preference-fraction

    0.75f

    Only used when the dfs.datanode.fsdataset.volume.choosing.policy is set to org.apache.hadoop.hdfs.server.datanode.fsdataset.AvailableSpaceVolumeChoosingPolicy. This setting controls what percentage of new block allocations will be sent to volumes with more available disk space than others. This setting should be in the range 0.0 - 1.0, though in practice 0.5 - 1.0, since there should be no reason to prefer that volumes with less available disk space receive more block allocations.

    另附上其他的一些类分析：

     

    DataNode的相关重要类

     

    FSDataset:所有和数据块相关的操作，都在FSDataset相关的类。详细分析参考 http://caibinbupt.iteye.com/blog/284365

    DataXceiverServer:处理数据块的流读写的的服务器,处理逻辑由DataXceiver完成。详细分析参考 http://caibinbupt.iteye.com/blog/284979

    DataXceiver:处理数据块的流读写的线程。详细分析参考 http://caibinbupt.iteye.com/blog/284979

    还有处理非读写的非主流的流程。详细分析参考 http://caibinbupt.iteye.com/blog/286533

    BlockReceiver:完成数据块的流写操作。详细分析参考 http://caibinbupt.iteye.com/blog/286259

    BlockSender:完成数据块的流读操作。

    DataBlockScanner:用于定时对数据块文件进行校验。详细分析参考http://caibinbupt.iteye.com/blog/286650

javastart
关注
专栏目录
CDH6.3.2更换HDFS 数据目录
qq_42452933的博客
09-13 782
CDH6.3.2更换HDFS 数据目录 事情是这样的，楼主刚入职一家新公司，刚开始搭建的集群时ecs只有一个系统盘，集群安装完成运行几天后，分分钟就要爆了，于是申请增加磁盘，就有了下面这些尝试 查看未挂载的磁盘 lsblk -f fdisk /dev/vdb fdisk -l #3.格式化 mkfs.ext4 /dev/vdb #4.挂载 mkdir /data mount /dev/vdb /data/ #5.永久挂载 vim /etc/fstab ############### /dev/vdb /da
hadoop单个数据节点的不同存储路径的存储策略源码分析。
danssion的专栏
09-01 1958
hadoop单个数据节点的不同存储路径的存储策略源码分析。
DataNode文件系统源码分析
weixin_33720452的博客
11-12 197
在DataNode的本地存储空间上，与存储服务密切相关的，比如创建数据块，恢复数据块，数据块校验等相关的代码都在org.apache.hadoop.hdfs.server.datanode.fsdataset包下(代码版本CDH5.1)首先说下org.apache.hadoop.hdfs.server.datanode.fsdataset下的主要接口，FsDa...
HDFS 副本存放磁盘选择策略详解
MY BLOG
12-17 1041
在 HDFS 中，DataNode 将数据块存储到本地文件系统目录中，具体的目录可以通过配置 hdfs-site.xml 里面的 dfs.datanode.data.dir 参数。在典型的安装配置中，一般都会配置多个目录，并且把这些目录分别配置到不同的设备上，比如分别配置到不同的HDD（HDD的全称是Hard Disk Drive）和SSD（全称Solid State Drives，就是我们熟悉的固态硬盘）上。 当我们往 HDFS 上写入新的数据块，DataNode 将会使用 volume 选择策略来为这
Hadoop3.2.1 【 HDFS 】源码分析 : 文件系统数据集 [三]
张伯毅的专栏
11-17 3609
一.前言 BlockPoolSlice负责管理单个存储目录下单个块池的所有数据块； FsVolumeImpl则负责管理一个完整的存储目录下所有的数据块， 也就包括了这个存储目录下多个BlockPoolSlice对象的引用。 Datanode可以定义多个存储目录， 也就是定义多个FsVolumeImpl对象， 在HDFS中使用FsVolumeList对象统一管理Datanode上定义的多个FsVolumeImpl对象。 FsDatasetSpi是FsDatasetImpl的根接口， 定义了Datanode管
hadoop 3.3.2源码包
05-06
Hadoop 3.3.2源码包是Apache Hadoop项目的一个重要版本，它是一个开源框架，主要用于存储和处理大规模数据。Hadoop的核心组件包括HDFS（Hadoop Distributed File System）和MapReduce，这两个组件构成了大数据处理的...
Hadoop学习总结.doc
10-26
#### 六、MapReduce源码分析总结 深入分析MapReduce的源代码可以帮助理解其内部实现细节，包括但不限于任务调度、资源管理、数据传输等机制。 综上所述，Hadoop是一个强大的分布式计算平台，它通过HDFS和MapReduce...
hadoop MapReduce源码分析(源码流程&word count日志)
master-dragon的专栏
11-13 884
工具准备 jdk-8u151-linux-x64.tar.gz hadoop-2.7.4.tar.gz centos64bit 修改hostname=centos(/etc/sysconfig/network) /etc/hosts中添加映射(ip -> hostname)192.168.14.142 centos 环境配置jdk ,hadoop安装都只需要直接解压，然后配置环境变量检测就行/e
Hadoop 大数据 期末复习题
qq_51685718的博客
12-22 2万+
1下面哪个选项属于大数据技术的“数据存储和管理”技术层面的功能? A、利用分布式文件系统、数据仓库、关系数据库等实现对结构化、半结构化和非结构化海量数据的存储和管理 B、利用分布式并行编程模型和计算框架,结合机器学习和数据挖掘算法,实现对海量数据的处理和分析 C、构建隐私数据保护体系和数据安全体系,有效保护个人隐私和数据安全 D、把实时采集的数据作为流计算系统的输入,进行实时处理分析 我的答案：A 2下列哪个不属于Hadoop的特性? A、成本高 B、高可靠性 C、高容错性 D、运行在Linux平台上 我的
Tensorflow分布式框架 解决Graph is finalized and cannot be modified问题
sinat_28375239的博客
09-03 3107
Tensorflow分布式框架 解决Graph is finalized and cannot be modified问题 如果使用MonitoredTrainingSession创建Session，不需要再初始化变量，错误示例： while not sess.should_stop(): sess.run(tf.global_variables_initializer()) 并且注意也不能在MonitoredTrainingSession之后进行任何初始化操作，包括数据初始化或变量初始化（应该放
Hadoop HDFS源码学习笔记（四）
一剪梅
03-13 1670
一、首先根据HDFS的API写一段程序，然后是用Eclipse进行debug 单步跟踪，从而查看源码执行流程： import java.net.URI; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs
源码|HDFS之DataNode：启动过程
weixin_34365417的博客
01-29 369
掌握Mac编译Hadoop源码与Hadoop单步debug追源码后，就能告别人肉调用栈，利用IDE轻松愉快的追各种开源框架的源码啦~ 今天是HDFS中DataNode的第一篇——DataNode启动过程。 源码版本：Apache Hadoop 2.6.0 可参考猴子追源码时的速记打断点，亲自debug一遍。 在开始之前 总览 HDFS-2.x与1.x的核心区别： 为支持Federatio...
Hadoop学习笔记
weixin_42118315的博客
09-25 284
Apache Hadoop （背景介绍、安装、环境配置） 背景 1.HADOOP最早起源于Nutch。Nutch的设计目标是构建一个大型的全网搜索引擎，包括网页抓取、索引、查询等功能，但随着抓取网页数量的增加，**遇到了严重的可扩展性问题——**如何解决数十亿网页的存储和索引问题。 2.随着信息化互联网|物联网发展要求，万物互联趋势势在必行。随之引发架构的演变由单一架构向高并发分布式架构演变。数据的存储也开始由原始的单机存储演变为分布式存储。 数据存储结构了解 ​ 1.JavaWeb:为了应对高并发和分布式
3.hadoop源码分析：datanode的注册分析
colossus——bigdata的专栏
03-02 1044
1.Pig是基于hadoop的一个数据处理的框架。 MapReduce是使用java进行开发的，Pig有一套自己的数据处理语言，Pig的数据处理过程要转化为MR来运行。 2.Pig的数据处理语言是数据流方式的，类似于初中做的数学题。 3.Pig基本数据类型：int、long、float、double、chararry、bytearray 复合数据类型：Map、Tuple、Bag ...
Hadoop常见错误及解决办法汇总
热门推荐
Jacob
01-12 3万+
错误一：java.io.IOException: Incompatible clusterIDs 时常出现在namenode重新格式化之后 ' V0 h# C5 a8 o+ ^1 n * w- t  k( ]$ }+ p6 d  G2014-04-29 14:32:53,877 FATAL org.apache.hadoop.hdfs.server.datanode.DataNode: Ini
hadoop Datanode多目录配置
weixin_30907523的博客
08-06 593
1. DataNode也可以配置成多个目录，每个目录存储的数据不一样。即：数据不是副本2．具体配置如下 hdfs-site.xml <property> <name>dfs.datanode.data.dir</name> <value>file:///${hadoop.tmp.dir}/dfs/data1,file:///${hadoo...
Hadoop学习总结之二：HDFS读写过程解析
forfuture1978的专栏
11-10 4742
一、文件的打开 1.1、客户端 HDFS打开一个文件，需要在客户端调用DistributedFileSystem.open(Path f, int bufferSize)，其实现为： public FSDataInputStream open(Path f, int bufferSize) throws IOException {   return new DFSClient.DFSDataInputStream(     
构建Hadoop驱动的统一数据存储与分析平台
本文档探讨了基于Hadoop的统一数据存储和分析平台，由EMC Corporation提供的一种解决方案。该平台的核心是EMC大数据分析平台Greenplum Chorus，它结合了Hadoop的分布式存储和处理能力与Greenplum数据库的高性能企业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值