Apache_Spark源码走读系列篇二

超人学院—Apache Spark源码走读之Task运行期之函数调用关系分析

欢迎转载，转载请注明出处，超人学院。

概要

本篇主要阐述在TaskRunner中执行的task其业务逻辑是如何被调用到的，另外试图讲清楚运行着的task其输入的数据从哪获取，处理

的结果返回到哪里，如何返回。

准备

1.spark已经安装完毕

2.spark运行在local mode或local-cluster mode

local-cluster mode

local-cluster模式也称为伪分布式，可以使用如下指令运行

MASTER=local[1,2,1024] bin/spark-shell

[1,2,1024]分别表示，executor number, core number和内存大小，其中内存大小不应小于默认的512M

Driver Programme的初始化过程分析

初始化过程的涉及的主要源文件

1.SparkContext.scala 整个初始化过程的入口

2.SparkEnv.scala 创建BlockManager,

MapOutputTrackerMaster, ConnectionManager, CacheManager

3.DAGScheduler.scala 任务提交的入口，即将Job

划分成各个stage的关键

4.TaskSchedulerImpl.scala 决定每个stage可以运行几个task，

每个task分别在哪个executor上运行

5.SchedulerBackend

1.最简单的单机运行模式的话，看LocalBackend.scala

2.如果是集群模式，看源文件

SparkDeploySchedulerBackend

初始化过程步骤详解

步骤1：根据初始化入参生成SparkConf，再根据SparkConf来创建SparkEnv, SparkEnv中主要包含以下关键性组件 1. BlockManager 2. MapOutputTracker 3. ShuffleFetcher 4. ConnectionManager

private[spark] val env = SparkEnv.create(

conf,

"",

conf.get("spark.driver.host"),

conf.get("spark.driver.port").toInt,

isDriver = true,

isLocal = isLocal)

SparkEnv.set(env)

步骤2：创建TaskScheduler,根据Spark的运行模式来选择相应的SchedulerBackend，同时启动taskscheduler，这一步至为关键

private[spark] var taskScheduler =

SparkContext.createTaskScheduler(this, master, appName)

taskScheduler.start()

TaskScheduler.start目的是启动相应的SchedulerBackend，并启动定时器进行检测

overridedef start() {

backend.start()

if (!isLocal && conf.getBoolean("spark.speculation", false)) {

logInfo("Starting speculative execution thread") import sc.env.actorSystem.dispatcher

sc.env.actorSystem.scheduler.schedule(SPECULATION_INTERVAL milliseconds,

SPECULATION_INTERVAL milliseconds) {

checkSpeculatableTasks()

}

}

}

步骤3：以上一步中创建的TaskScheduler实例为入参创建DAGScheduler并启动运行

@volatileprivate[spark] var dagScheduler = new DAGScheduler(taskScheduler)

dagScheduler.start()

步骤4：启动WEB UI

ui.start()

RDD的转换过程

还是以最简单的wordcount为例说明rdd的转换过程

sc.textFile("README.md").flatMap(line=>line.split(" ")).map(word => (word, 1)).reduceByKey(_ + _)

上述一行简短的代码其实发生了很复杂的RDD转换，下面仔细解释每一步的转换过程和转换结果

步骤1：val rawFile = sc.textFile("README.md")

textFile先是生成hadoopRDD，然后再通过map操作生成MappedRDD,

如果在spark-shell中执行上述语句，得到的结果可以证明所做的分

析

scala> sc.textFile("README.md")

14/04/2313:11:48 WARN SizeEstimator: Failed to check whether UseCompressedOops is set; assuming yes

14/04/2313:11:48 INFO MemoryStore: ensureFreeSpace(119741)

called with curMem=0, maxMem=311387750

14/04/2313:11:48 INFO MemoryStore: Block broadcast_0 stored as

values to memory (estimated size 116.9 KB, free 296.8 MB)

14/04/2313:11:48 DEBUG BlockManager: Put block broadcast_0

locally took 277 ms

14/04/2313:11:48 DEBUG BlockManager: Put for block broadcast_0

without replication took 281 ms

res0: org.apache.spark.rdd.RDD[String] = MappedRDD[1] at

textFile at :13

步骤2: val splittedText = rawFile.flatMap(line =>

line.split(" "))

flatMap将原来的MappedRDD转换成为FlatMappedRDD

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

= new FlatMappedRDD(this, sc.clean(f))

步骤3：val wordCount = splittedText.map(word => (word, 1))

利用word生成相应的键值对，上一步的FlatMappedRDD被转换成为

MappedRDD

步骤4：val reduceJob = wordCount.reduceByKey(_ + _)，这一步最复杂

步骤2，3中使用到的operation全部定义在RDD.scala中，而这里使用到的reduceByKey却在RDD.scala中见不到踪迹。reduceByKey 的定义出现在源文件PairRDDFunctions.scala

细心的你一定会问reduceByKey不是MappedRDD的属性和方法啊，怎么能被MappedRDD调用呢？其实这背后发生了一个隐式的转换，该转换将MappedRDD转换成为PairRDDFunctions

implicit def rddToPairRDDFunctions[K: ClassTag, V: ClassTag](rdd: RDD[(K, V)]) =

new PairRDDFunctions(rdd)

这种隐式的转换是scala的一个语法特征，如果想知道的更多，请用关键字"scala implicit method"进行查询，会有不少的文章对此进行详尽的介绍。

接下来再看一看reduceByKey的定义

def reduceByKey(func: (V, V) => V): RDD[(K, V)] = {

reduceByKey(defaultPartitioner(self), func)

}

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = {

combineByKey[V]((v: V) => v, func, func, partitioner)

}

def combineByKey[C](createCombiner: V => C,

mergeValue: (C, V) => C,

mergeCombiners: (C, C) => C,

partitioner: Partitioner,

mapSideCombine: Boolean = true,

serializerClass: String = null): RDD[(K, C)] = {

if (getKeyClass().isArray) {

if (mapSideCombine) {

thrownew SparkException("Cannot use map-side combining with array keys.")

}

if (partitioner.isInstanceOf[HashPartitioner]) {

thrownew SparkException("Default partitioner cannot partition array keys.")

}

}

val aggregator = new Aggregator[K, V, C](createCombiner, mergeValue, mergeCombiners)

if (self.partitioner == Some(partitioner)) {

self.mapPartitionsWithContext((context, iter) => { new InterruptibleIterator(context,

https://www.wendangku.net/doc/157958934.html,bineValuesByKey(iter, context))

}, preservesPartitioning = true)

} elseif (mapSideCombine) {

val combined = self.mapPartitionsWithContext((context, iter) => {

https://www.wendangku.net/doc/157958934.html,bineValuesByKey(iter, context)

}, preservesPartitioning = true)

val partitioned = new ShuffledRDD[K, C, (K, C)](combined, partitioner)

.setSerializer(serializerClass)

partitioned.mapPartitionsWithContext((context, iter) => {

new InterruptibleIterator(context,

https://www.wendangku.net/doc/157958934.html,bineCombinersByKey(iter, context))

}, preservesPartitioning = true)

} else {

// Don't apply map-side combiner.

val values = new ShuffledRDD[K, V, (K, V)](self, partitioner).setSerializer(serializerClass)

values.mapPartitionsWithContext((context, iter) => { new InterruptibleIterator(context,

https://www.wendangku.net/doc/157958934.html,bineValuesByKey(iter, context))

}, preservesPartitioning = true)

}

}

reduceByKey最终会调用combineByKey, 在这个函数中PairedRDDFunctions会被转换成为ShuffleRDD,当调用mapPartitionsWithContext之后，shuffleRDD被转换成为MapPartitionsRDD

Log输出能证明我们的分析

res1: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at reduceByKey at :13

RDD转换小结

小结一下整个RDD转换过程

HadoopRDD->MappedRDD->FlatMappedRDD->MappedRDD->PairRDDFunc tions->ShuffleRDD->MapPartitionsRDD

整个转换过程好长啊，这一切的转换都发生在任务提交之前。

运行过程分析

数据集操作分类

在对任务运行过程中的函数调用关系进行分析之前，我们也来探讨一个偏理论的东西，作用于RDD之上的Transformantion为什么会是这个样子？

对这个问题的解答和数学搭上关系了，从理论抽象的角度来说，任务

处理都可归结为“input->processing->output"。input和output

对应于数据集dataset.

在此基础上作一下简单的分类

1.one-one 一个dataset在转换之后还是一个dataset，而且

dataset的size不变，如map

2.one-one 一个dataset在转换之后还是一个dataset，但size

发生更改，这种更改有两种可能：扩大或缩小，如flatMap是

size增大的操作，而subtract是size变小的操作

3.many-one 多个dataset合并为一个dataset，如combine, join

4.one-many 一个dataset分裂为多个dataset, 如groupBy

Task运行期的函数调用

task的提交过程参考本系列中的第二篇文章。本节主要讲解当task

在运行期间是如何一步步调用到作用于RDD上的各个operation

TaskRunner.run

o Task.run

?Task.runTask (Task是一个基类，有两个子类，分

别为ShuffleMapTask和ResultTask)

?RDD.iterator

?https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint

?https://www.wendangku.net/doc/157958934.html,pute

或许当看到https://www.wendangku.net/doc/157958934.html,pute函数定义时，还是觉着f没有被调用,以

MappedRDD的compute定义为例

overridedef compute(split: Partition, context: TaskContext) = firstParent[T].iterator(split, context).map(f)

注意，这里最容易产生错觉的地方就是map函数，这里的map不是

RDD中的map，而是scala中定义的iterator的成员函数map, 请自

行参考

https://www.wendangku.net/doc/157958934.html,/api/2.10.4/index.html#scala.colle ction.Iterator

堆栈输出

80 at

org.apache.spark.rdd.HadoopRDD.getJobConf(HadoopRDD.scala:1 11)

81 at

org.apache.spark.rdd.HadoopRDD$$anon$1.(HadoopRDD.scala:154 )

82 at

https://www.wendangku.net/doc/157958934.html,pute(HadoopRDD.scala:149) 83 at

https://www.wendangku.net/doc/157958934.html,pute(HadoopRDD.scala:64) 84 at

https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint(RDD.scala: 241)

85 at

org.apache.spark.rdd.RDD.iterator(RDD.scala:232)

86 at

https://www.wendangku.net/doc/157958934.html,pute(MappedRDD.scala:31) 87 at

https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint(RDD.scala: 241)

88 at

org.apache.spark.rdd.RDD.iterator(RDD.scala:232)

89 at

https://www.wendangku.net/doc/157958934.html,pute(FlatMappedRDD.sc ala:33)

90 at

https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint(RDD.scala: 241)

91 at

org.apache.spark.rdd.RDD.iterator(RDD.scala:232)

92 at

https://www.wendangku.net/doc/157958934.html,pute(MappedRDD.scala:31) 93 at

https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint(RDD.scala: 241)

94 at

org.apache.spark.rdd.RDD.iterator(RDD.scala:232)

95 at

https://www.wendangku.net/doc/157958934.html,pute(MapPartitions RDD.scala:34)

96 at

https://www.wendangku.net/doc/157958934.html,puteOrReadCheckpoint(RDD.scala: 241)

97 at

org.apache.spark.rdd.RDD.iterator(RDD.scala:232)

98 at

org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMa pTask.scala:161)

99 at

org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMa pTask.scala:102)

100 at

org.apache.spark.scheduler.Task.run(Task.scala:53)

101 at

org.apache.spark.executor.Executor$TaskRunner$$anonfun$run$ 1.apply$mcV$sp(Executor.scala:211)

ResultTask

compute的计算过程对于ShuffleMapTask比较复杂，绕的圈圈比较多，对于ResultTask就直接许多。

overridedef runTask(context: TaskContext): U = {

metrics = Some(context.taskMetrics)

try {

func(context, rdd.iterator(split, context))

} finally {

context.executeOnCompleteCallbacks()

}

}

计算结果的传递

上面的分析知道，wordcount这个job在最终提交之后，被DAGScheduler分为两个stage，第一个Stage是shuffleMapTask，第二个Stage是ResultTask.

那么ShuffleMapTask的计算结果是如何被ResultTask取得的呢？这个过程简述如下

1.ShffuleMapTask将计算的状态(注意不是具体的数据)包装为

MapStatus返回给DAGScheduler

2.DAGScheduler将MapStatus保存到MapOutputTrackerMaster

中

3.ResultTask在执行到ShuffleRDD时会调用

BlockStoreShuffleFetcher的fetch方法去获取数据

1.第一件事就是咨询MapOutputTrackerMaster所要取的数

据的location

2.根据返回的结果调用BlockManager.getMultiple获取真

正的数据

BlockStoreShuffleFetcher的fetch函数伪码

val blockManager = SparkEnv.get.blockManager

val startTime = System.currentTimeMillis

val statuses =

SparkEnv.get.mapOutputTracker.getServerStatuses(shuffleId, reduceId)

logDebug("Fetching map output location for shuffle %d, reduce %d took %d ms".format(

shuffleId, reduceId, System.currentTimeMillis - startTime))

val blockFetcherItr =

blockManager.getMultiple(blocksByAddress, serializer)

val itr = blockFetcherItr.flatMap(unpackBlock)

注意上述代码中的getServerStatuses及getMultiple,一个是询问数据的位置，一个是去获取真正的数据。

Android Hotfix 新方案——Amigo 源码解读

Android Hotfix 新方案——Amigo 源码解读 首先我们先来看看如何使用这个库。 用法 在project 的build.gradle中 dependencies { classpath 'me.ele:amigo:0.0.3' } 在module 的build.gradle中 apply plugin: 'me.ele.amigo' 就这样轻松的集成了Amigo。 生效补丁包 补丁包生效有两种方式可以选择： ? 稍后生效补丁包 ? 如果不想立即生效而是用户第二次打开App 时才打入补丁包，则可以将新的Apk 放到/data/data/{your pkg}/files/amigo/demo.apk，第二次打开时就会自动生效。可以通过这个方法 ? File hotfixApk = Amigo.getHotfixApk(context); ?

获取到新的Apk。 同时，你也可以使用Amigo 提供的工具类将你的补丁包拷贝到指定的目录当中。 ? FileUtils.copyFile(yourApkFile, amigoApkFile); ? ? 立即生效补丁包 ? 如果想要补丁包立即生效，调用以下两个方法之一，App 会立即重启， 并且打入补丁包。 ? Amigo.work(context); ? Amigo.work(context, apkFile); ? 删除补丁包 如果需要删除掉已经下好的补丁包，可以通过这个方法 Amigo.clear(context); 提示：如果apk 发生了变化，Amigo 会自动清除之前的apk。 自定义界面 在热修复的过程中会有一些耗时的操作，这些操作会在一个新的进程中的Activity 中执行，所以你可以通过以下方式来自定义这个Activity。

安卓计算机源代码

Mxl代码

如何阅读别人代码

如何阅读别人代码 code reading ++++++++++++ 第一章: 导论 ++++++++++++ 1.要养成一个习惯, 经常花时间阅读别人编写的高品质代码. 2.要有选择地阅读代码, 同时, 还要有自己的目标. 您是想学习新的模式|编码风格|还是满足某些需求的方法. 3.要注意并重视代码中特殊的非功能性需求, 这些需求也许会导致特殊的实现风格. 4.在现有的代码上工作时, 请与作者和维护人员进行必要的协调, 以避免重复劳动或产生厌恶情绪. 5.请将从开放源码软件中得到的益处看作是一项贷款, 尽可能地寻找各种方式来回报开放源码社团. 6.多数情况下, 如果您想要了解"别人会如何完成这个功能呢?", 除了阅读代码以外, 没有更好的方法. 7.在寻找bug时, 请从问题的表现形式到问题的根源来分析代码. 不要沿着不相关的路径(误入歧途). 8.我们要充分利用调试器|编译器给出的警告或输出的符号代码|系统调用跟踪器|数据库结构化查询语言的日志机制|包转储工具和Windows的消息侦查程序, 定出的bug的位置. 9.对于那些大型且组织良好的系统, 您只需要最低限度地了解它的全部功能, 就能够对它做出修改. 10.当向系统中增加新功能时, 首先的任务就是找到实现类似特性的代码, 将它作为待实现功能的模板. 11.从特性的功能描述到代码的实现, 可以按照字符串消息, 或使用关键词来搜索代码. 12.在移植代码或修改接口时, 您可以通过编译器直接定位出问题涉及的范围, 从而减少代码阅读的工作量. 13.进行重构时, 您从一个能够正常工作的系统开始做起, 希望确保结束时系统能

Android源码下载方法详解

Android: Android源码下载方法详解 分类：Android平台 安卓源码下载地址：https://www.wendangku.net/doc/157958934.html,/source/downloading.html 相信很多下载过内核的人都对这个很熟悉 git clone git://https://www.wendangku.net/doc/157958934.html,/kernel/common.git kernel 但是这是在以前，现在如果这么执行的话，会显示如下内容 Initialized empty Git repository in /home/star/working/kernel/.git/ https://www.wendangku.net/doc/157958934.html,[0: 149.20.4.77]: errno=Connection refused fatal: unable to connect a socket (Connection refused) 通过浏览器输入https://www.wendangku.net/doc/157958934.html,/，发现该网站已经被重定向为 https://www.wendangku.net/doc/157958934.html,/source/downloading.html 可以在该页面的最后发现内核的下载方法。 下面我们介绍一下Android源码下载的步骤。 工作环境： 操作系统：Ubuntu 10.04 或Ubuntu10.10 git程序：1.7.0.4 或1.7.1 转载请注明出处：https://www.wendangku.net/doc/157958934.html,/pku_android 方法一： 1.1 初始化安装环境 参考网页https://www.wendangku.net/doc/157958934.html,/source/initializing.html 主要要做的就是安装jdk和安装一些软件包 $ sudo apt-get install git-core gnupg flex bison gperf build-essential \ zip curl zlib1g-dev libc6-dev libncurses5-dev x11proto-core-dev \ libx11-dev libreadline6-dev libgl1-mesa-dev tofrodos python-markdown \ libxml2-utils 如果已经安装了，就不许要这步了 1.2 无论下载内核和源码，都需要进行如下操作 参考网页https://www.wendangku.net/doc/157958934.html,/source/downloading.html $ mkdir ~/bin $ PATH=~/bin:$PATH $ curl https://https://www.wendangku.net/doc/157958934.html,/dl/googlesource/git-repo/repo > ~/bin/repo 如果出现: repo init error: could not verify the tag 'v1.12.7',

Android计算器源码

计算器源码 Java程序代码： package ymq.demo03; import android.app.Activity; import android.os.Bundle; import android.view.*; import android.widget.*; public class demo03 extends Activity { /** Called when the activity is first created. */ String str=""; EditText et; int c=0,flag=0; double b=0.0,g=0.0,f=0.0; View vi; public boolean onCreateOptionsMenu(Menu menu) { // TODO Auto-generated method stub menu.add(0, 1, 1, "退出"); return super.onCreateOptionsMenu(menu); } @Override public boolean onOptionsItemSelected(MenuItem item) { // TODO Auto-generated method stub if(item.getItemId()==1){finish();} return super.onOptionsItemSelected(item); } //计算方法 public double calculater(){ switch(c){ case 0:f=g;break; case 1:f=b+g;break; case 2:f=b-g;break; case 3:f=b*g;break; case 4:f=b/g;break; } b=f;

java 基础知识之hadoop源码阅读必备(一)

java 程序员你真的懂java吗？ 一起来看下hadoop中的如何去使用java的 大数据是目前IT技术中最火热的话题，也是未来的行业方向，越来越多的人参与到大数据的学习行列中。从最基础的伪分布式环境搭建，再到分布式环境搭建，再进入代码的编写工作。这时候码农和大牛的分界点已经出现了，所谓的码农就是你让我做什么我就做什么，我只负责实现，不管原理，也不想知道原理。大牛就开始不听的问自己why？why？why？于是乎，很自然的去看源码了。然而像hadoop这样的源码N多人参与了修改和完善，看起来非常的吃力。然后不管如何大牛就是大牛，再硬的骨头也要啃。目前做大数据的80%都是从WEB开发转变过来的，什么spring mvc框架、SSH框架非常熟悉，其实不管你做了多少年的WEB开发，你很少接触到hadoop中java代码编写的风格，有些人根本就看不懂什么意思。下面我来介绍下hadoop源码怎么看。 hadoop体现的是分布式框架，因此所有的通信都基于RPC来操作，关于RPC的操作后续再介绍。hadoop源码怎么看系列分多个阶段介绍，下面重点介绍下JA V A基础知识。 一、多线程编程 在hadoop源码中，我们能看到大量的类似这样的代码 return executor.submit(new Callable() { @Override public String call() throws Exception { //方法类 } 下面简单介绍下java的多线程编程 启动一个线程可以使用下列几种方式 1、创建一个Runnable，来调度，返回结果为空。 ExecutorService executor = Executors.newFixedThreadPool(5); executor.submit(new Runnable() { @Override public void run() { System.out.println("runnable1 running."); } }); 这种方式启动一个线程后，在后台运行，不用等到结果，因为也不会返回结果 2、创建一个Callable，来调度，有返回结果 Future future1 = executor.submit(new Callable() { @Override public String call() throws Exception { // TODO Auto-generated method stub //具体执行一些内部操作 return "返回结果了！"; } }); System.out.println("task1: " + future1.get());

Android源代码结构分析

目录 一、源代码结构 (2) 第一层次目录 (2) bionic目录 (3) bootloader目录 (5) build目录 (7) dalvik目录 (9) development目录 (9) external目录 (13) frameworks目录 (19) Hardware (20) Out (22) Kernel (22) packages目录 (22) prebuilt目录 (27) SDK (28) system目录 (28) Vendor (32)

一、源代码结构 第一层次目录 Google提供的Android包含了原始Android的目标机代码，主机编译工具、仿真环境，代码包经过解压缩后，第一级别的目录和文件如下所示： . |-- Makefile （全局的Makefile） |-- bionic （Bionic含义为仿生，这里面是一些基础的库的源代码） |-- bootloader （引导加载器），我们的是bootable， |-- build （build目录中的内容不是目标所用的代码，而是编译和配置所需要的脚本和工具） |-- dalvik （JAVA虚拟机） |-- development （程序开发所需要的模板和工具） |-- external （目标机器使用的一些库） |-- frameworks （应用程序的框架层） |-- hardware （与硬件相关的库） |-- kernel （Linux2.6的源代码） |-- packages （Android的各种应用程序） |-- prebuilt （Android在各种平台下编译的预置脚本） |-- recovery （与目标的恢复功能相关） `-- system （Android的底层的一些库）

Linux 0.1.1文件系统的源码阅读

Linux 0.11文件系统的源码阅读总结 1.minix文件系统 对于linux 0.11内核的文件系统的开发，Linus主要参考了Andrew S.Tanenbaum 所写的《MINIX操作系统设计与实现》，使用的是其中的1.0版本的MINIX文件系统。而高速缓冲区的工作原理参见M.J.Bach的《UNIX操作系统设计》第三章内容。 通过对源代码的分析，我们可以将minix文件系统分为四个部分，如下如1-1。 ●高速缓冲区的管理程序。主要实现了对硬盘等块设备进行数据高速存取的函数。 ●文件系统的底层通用函数。包括文件索引节点的管理、磁盘数据块的分配和释放 以及文件名与i节点的转换算法。 ●有关对文件中的数据进行读写操作的函数。包括字符设备、块设备、管道、常规 文件的读写操作，由read_write.c函数进行总调度。 ●涉及到文件的系统调用接口的实现，这里主要涉及文件的打开、关闭、创建以及 文件目录等系统调用，分布在namei和inode等文件中。 图1-1 文件系统四部分之间关系图

1.1超级块 首先我们了解一下MINIX文件系统的组成，主要包括六部分。对于一个360K软盘，其各部分的分布如下图1-2所示： 图 1-2 建有MINIX文件系统的一个360K软盘中文件系统各部分的布局示意图 注释1：硬盘的一个扇区是512B，而文件系统的数据块正好是两个扇区。 注释2：引导块是计算机自动加电启动时可由ROM BIOS自动读入得执行代码和数据。 注释3：逻辑块一般是数据块的2幂次方倍数。MINIX文件系统的逻辑块和数据块同等大小 对于硬盘块设备，通常会划分几个分区，每个分区所存放的不同的文件系统。硬盘的第一个扇区是主引导扇区，其中存放着硬盘引导程序和分区表信息。分区表中得信息指明了硬盘上每个分区的类型、在硬盘中其实位置参数和结束位置参数以及占用的扇区总数。其结构如下图1-3所示。 图1-3 硬盘设备上的分区和文件系统 对于可以建立不同的多个文件系统的硬盘设备来说，minix文件系统引入超级块进行管理硬盘的文件系统结构信息。其结构如下图1-4所示。其中，s_ninodes表示设备上得i节点总数，s_nzones表示设备上的逻辑块为单位的总逻辑块数。s_imap_blocks 和s_zmap_blocks分别表示i节点位图和逻辑块位图所占用的磁盘块数。 s_firstdatazone表示设备上数据区开始处占用的第一个逻辑块块号。s_log_zone_size 是使用2为底的对数表示的每个逻辑块包含的磁盘块数。对于MINIX1.0文件系统该值为0，因此其逻辑块的大小就等于磁盘块大小。s_magic是文件系统魔幻数，用以指明文件系统的类型。对于MINIX1.0文件系统，它的魔幻数是0x137f。

Android USB 驱动分析

Android USB 驱动分析 一、USB驱动代码架构和使用 1、代码简介 USB驱动代码在/drivers/usb/gadget下，有三个文件:android.c， f_adb.c， f_mass_storage.c；g_android.ko 是由这三个文件编译而来，其中android.c 依赖于 f_adb.c 和 f_mass_storage.c(这两个文件之间无依赖关系)。 可在android.c中看到： static int __init android_bind_config(struct usb_configuration *c) { struct android_dev *dev = _android_dev; int ret; printk(KERN_DEBUG "android_bind_config\n"); ret = mass_storage_function_add(dev->cdev, c, dev->nluns); if (ret) return ret; return adb_function_add(dev->cdev, c); } 2、驱动使用 要使USB mass storage连接到主机： 打开/sys/devices/platform/usb_mass_storage/lun0/file文件，向 file文件写入一个存储 设备的路径，例如/dev/block/vold/179:0 (major:minor)路径； 这里的usb_mass_storage根据实际应用可以改的，由 platform_device_register函数的参数决 定。 例如： static struct platform_device fsg_platform_device = { .name = "usb_mass_storage", .id = -1, }; static void __init tegra_machine_init(void) { .... (void) platform_device_register(&fsg_platform_device); .... }

基于Android的手机计步器的设计与实现源代码

基于A n d r o i d的手机计步器的设计与实现源 代码 Standardization of sany group #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN#

专业工程综合实训设计报告

目录

第一章绪论 课题的背景及意义 当今社会，手机已经成为人们工作生活中必不可少的一项通讯和娱乐工具，随着手机的不断更新，手机的各种高层服务和应用层出不穷。现在智能手机可谓是爆发式增长，与此同时传统手机在不断地消失，诺基亚就是在这样的环境中受到了重创。现在主要有三个使用率和关注度最高的手机平台，分别是：Android，ios和windows phone平台，在这三个平台中Android的占有率最高。自2007年11月Google公司发布Android系统以来，短短几年时间，Android已经占据了智能手机市场的半壁江山，成为目前最为炙手可热的智能手机操作系统。Android走进了越来越多人的生活，成为他们获取信息的主要平台。 Android平台对于Google和用户的意义不在于手机本身，而在于为了推动移动互联网产业链的迅速成型。具有开源性的Android手机平台与之前Symbian、windows mobile等操作系统不同，它们收取高额的授权费用，而Android不需要，这样使得应用开发成本大大降低；也正是由于它的源代码是开放的，使得开发者可以随心所欲的开发应用。同时，手机生产商和软件开发商也能够在这里得到利润，手机软件得到有效的维护协调发展。这正是Google发布Android平台的意义，也是Android平台的使命所在。 同时目前搭载Android平台的应用有很多，但针对传感器而开发的应用市场上还不多见。本应用正是针对Android手机内置的加速度传感器而特别设计的应用。所以鉴于移动端应用开发是目前软件开发行业正在兴起并会越来越炙手可热的一个分支，并且针对传感器的开发相对空白我选择了研究此课题。 系统框架 在设计一款软件时一般都会把它分成几个模块，在模块的基础上还会再分小模块，这样就达到了软件模块化设计的要求，然后再对各个小模块进行详细设计和编写，采用模块化的管理方式可以使软件结构更清晰，也使得软件的管理更有秩序，使别人容易理解和阅读，但是这些模块也要根据别的模块来设计和约束，不能随便设计脱离框架，设计完成后需要把每个设计完成的模块根据总体框架结合起来。 根据本软件的功能需求，将本软件分为以下几个功能模块，如图 1-1所示：

源代码是什么

源代码是什么 源代码（也称源程序），是指一系列人类可读的计算机语言指令。在现代程序语言中，源代码可以是以书籍或者磁带的形式出现，但最为常用的格式是文本文件，这种典型格式的目的是为了编译出计算机程序。计算机源代码的最终目的是将人类可读的文本翻译成为计算机可以执行的二进制指令，这种过程叫做编译，通过编译器完成。 代码组合 源代码作为软件的特殊部分，可能被包含在一个或多个文件中。一个程序不必用同一种格式的源代码书写。例如，一个程序如果有C语言库的支持，那么就可以用C语言；而另一部分为了达到比较高的运行效率，则可以用汇编语言编写。较为复杂的软件，一般需要数十种甚至上百种的源代码的参与。为了降低种复杂度，必须引入一种可以描述各个源代码之间联系，并且如何正确编译的系统。在这样的背景下，修订控制系统（RCS）诞生了，并成为研发者对代码修订的必备工具之一。还有另外一种组合：源代码的编写和编译分别在不同的平台上实现，专业术语叫做软件移植。 质量 对于计算机而言，并不存在真正意义上的“好”的源代码；然而作为一个人，好的书写习惯将决定源代码的好坏。源代码是否具有可读性，成为好坏的重要标准。软件文档则是表明可读性的关键。 作用 源代码主要功用有如下2种作用： 生成目标代码，即计算机可以识别的代码。 对软件进行说明，即对软件的编写进行说明。为数不少的初学者，甚至少数有经验的程序员都忽视软件说明的编写，因为这部分虽然不会在生成的程序中直接显示，也不参与编译。但是说明对软件的学习、分享、维护和软件复用都有巨大的好处。因此，书写软件说明在业界被认为是能创造优秀程序的良好习惯，一些公司也硬性规定必须书写。

Android 串口编程原理和实现方式附源码

提到串口编程，就不得不提到JNI，不得不提到JavaAPI中的文件描述符类：。下面我分别对JNI、以及串口的一些知识点和实现的源码进行分析说明。这里主要是参考了开源项目android-serialport-api。 串口编程需要了解的基本知识点：对于串口编程，我们只需对串口进行一系列的设置，然后打开串口，这些操作我们可以参考串口调试助手的源码进行学习。在Java中如果要实现串口的读写功能只需操作文件设备类:即可，其他的事都由驱动来完成不用多管！当然，你想了解，那就得看驱动代码了。这里并不打算对驱动进行说明，只初略阐述应用层的实现方式。 （一）JNI： 关于JNI的文章网上有很多，不再多做解释，想详细了解的朋友可以查看云中漫步的技术文章，写得很好，分析也很全面，那么在这篇拙文中我强调3点： 1、如何将编译好的SO文件打包到APK中？（方法很简单，直接在工程目录下新建文件夹libs/armeabi，将SO文件Copy到此目录即可） 2、命名要注意的地方？（在编译好的SO文件中，将文件重命名为：lib即可。其中是编译好后生成的文件） 3、MakeFile文件的编写（不用多说，可以直接参考package/apps目录下用到JNI的相关项目写法） 这是关键的代码： [cpp]view plaincopy

（二）：

文件描述符类的实例用作与基础机器有关的某种结构的不透明句柄，该结构表示开放文件、开放套接字或者字节的另一个源或接收者。文件描述符的主要实际用途是创建一个包含该结构的或。这是API的描述，不太好理解，其实可简单的理解为：就是对一个文件进行读写。 （三）实现串口通信细节 1) 建工程：SerialDemo包名：org.winplus.serial，并在工程目录下新建jni和libs两个文件夹和一个org.winplus.serial.utils，如下图： 2) 新建一个类：SerialPortFinder，添加如下代码： [java]view plaincopy 1.package org.winplus.serial.utils; 2. 3.import java.io.File; 4.import java.io.; 5.import java.io.IOException; 6.import java.io.LineNumberReader; 7.import java.util.Iterator; 8.import java.util.Vector; 9. 10.import android.util.Log; 11. 12.public class SerialPortFinder { 13. 14.private static final String TAG = "SerialPort"; 15.

安卓日历开发源代码

App工程结构搭建：几种常见Android代码架构分析

App工程结构搭建：几种常见Android代码架构分析 关于Android架构，因为手机的限制，目前我觉得也确实没什么大谈特谈的，但是从开发的角度，看到整齐的代码，优美的分层总是一种舒服的享受的。 从艺术的角度看，其实我们是在追求一种美。 本文先分析几个当今比较流行的android软件包，最后我们汲取其中觉得优秀的部分，搭建我们自己的通用android工程模板。 1. 微盘 微盘的架构比较简单，我把最基本，最主干的画了出来： 第一层：com.sina.VDisk：com.sina(公司域名)+app(应用程序名称) 。 第二层：各模块名称（主模块VDiskClient和实体模块entities）第三层：各模块下具体子包，实现类。 从图中我们能得出上述分析中一个最简单最经典的结构，一般在应用程序包下放一些全局的包或者类，如果有多个大的模块，可以分成多个包，其中包括一个主模块。 在主模块中定义基类，比如BaseActivity等，如果主模块下还有子模块，可以在主模块下建立子模块相应的包。说明一点，有的时候如果只有一个主模块，我们完全可以省略掉模

块这一层，就是BaseActivity.java及其子模块直接提至第二层。 在实体模块中，本应该定义且只定义相应的实体类，供全局调用(然而实际情况可能不是这样，后面会说到)。在微盘应用中，几乎所有的实体类是以xxx+info命名的，这种命名也是我赞成的一种命名，从语义上我觉得xxxModel.java这种命名更生动更真实，xxxModel给我一种太机械太死板的感觉，这点完全是个人观点，具体操作中以个人习惯为主。还有一点，在具体的xxxInfo,java中有很多实体类中是没有get/set的方法，而是直接使用public的字段名。这一点，我是推荐这种方式的，特别是在移动开发中，get/set方法很多时候是完全没有必要的，而且是有性能消耗的。当然如果需要对字段设置一定的控制，get/set方法也是可以酌情使用的。 2. 久忆日记 相比于微盘的工程结构，久忆日记的结构稍微复杂了一些。如下图： 1).第一层和前面微盘一样的. 2).第二层则没有模块分类,直接把需要的具体实现类都放在下面，主要日记的一些日记相关的Activity。 3).第二层的实体包命令为model包，里面不仅存放了实体类

android开发——简易计算器的设计报告

简易计算机的设计 摘要：Android是当今最重要的手机开发平台之一，它是建立在Java基础之上的，能够迅速建立手机软件的解决方案。Android的功能十分强大，成为当今软件行业的一股新兴力量。Android基于Linux平台，由操作系统、中间件、用户界面和应用软件组成，具有以下5个特点：开放性、应用程序无界限、应用程序是在平等条件下创建的、应用程序可以轻松的嵌入网络、应用程序可以并行运行。 一、实训目的 1、了解Android系统，学会Android开发环境的搭建。 2、了解E clipse，学会用E clipse和Java 开发一个Android程序。 3、进一步巩固课堂上所学到的知识，深刻把握Java语言的重要概念及其面向对象的特性，能够熟练的应用面向对象的思想和设计方法解决实际问题的能力。 4、巩固所学Java语言基本知识，增进Java语言编辑基本功，掌握JDK、Editplus、Eclipse、JCreator等开发工具的运用，拓宽常用类库的应用。 二、实训任务 1、Activity的相关知识 简单理解Activity 代表一个用户所能看到的屏幕，Activity 主要是处理一个应用的整体性工作。Activity是最基本的Android 应用程序组件，应用程序中，一个活动通常就是一个单独的屏幕。每一个活动都被实现为一个独立的类，并且从活动基类中继承而来，活动类将会显示由视图控件组成的用户接口，并对事件做出响应。大多数的应用是由多个屏幕显示组成，因而要用到多个Activity。 （1）Activity的相关方法及相关函数：void onCreate(Bundle）首次启动时调用，接受参数：Null or savedInstanceState（保存的以前某些状态信息）；void onStart() 说明了将要显示给用户的活动；void onRestart()将处于停止状态的活动重新显示给用户；void onResume()用户可以开始与活动进行交互时

如何读源代码

如何阅读源代码 --转自CSDN_oncoding +++++++++++ 第一章: 导论 ++++++++++++ 1.要养成一个习惯, 经常花时间阅读别人编写的高品质代码. 2.要有选择地阅读代码, 同时, 还要有自己的目标. 您是想学习新的模式|编码风格|还是满足某些需求的方法. 3.要注意并重视代码中特殊的非功能性需求, 这些需求也许会导致特殊的实现风格. 4.在现有的代码上工作时, 请与作者和维护人员进行必要的协调, 以避免重复劳动或产生厌恶情绪. 5.请将从开放源码软件中得到的益处看作是一项贷款, 尽可能地寻找各种方式来回报开放源码社团. 6.多数情况下, 如果您想要了解"别人会如何完成这个功能呢?", 除了阅读代码以外, 没有更好的方法. 7.在寻找bug时, 请从问题的表现形式到问题的根源来分析代码. 不要沿着不相关的路径(误入歧途). 8.我们要充分利用调试器|编译器给出的警告或输出的符号代码|系统调用跟踪器|数据库结构化查询语言的日志机制|包转储工具和Windows的消息侦查程序, 定出的bug的位置. 9.对于那些大型且组织良好的系统, 您只需要最低限度地了解它的全部功能, 就能够对它做出修改. 10.当向系统中增加新功能时, 首先的任务就是找到实现类似特性的代码, 将它作为待实现功能的模板. 11.从特性的功能描述到代码的实现, 可以按照字符串消息, 或使用关键词来搜索代码. 12.在移植代码或修改接口时, 您可以通过编译器直接定位出问题涉及的范围, 从而减少代码阅读的工作量.

13.进行重构时, 您从一个能够正常工作的系统开始做起, 希望确保结束时系统能够正常工作. 一套恰当的测试用例(test case)可以帮助您满足此项约束. 14.阅读代码寻找重构机会时, 先从系统的构架开始, 然后逐步细化, 能够获得最大的效益. 15.代码的可重用性是一个很诱人, 但难以理解与分离, 可以试着寻找粒度更大一些的包, 甚至其他代码. 16.在复查软件系统时, 要注意, 系统是由很多部分组成的, 不仅仅只是执行语句. 还要注意分析以下内容: 文件和目录结构|生成和配置过程|用户界面和系统的文档. 18.可以将软件复查作为一个学习|讲授|援之以手和接受帮助的机会. ++++++++++++++++++++ 第二章: 基本编程元素 ++++++++++++++++++++ 19.第一次分析一个程序时, main是一个好的起始点. 20.层叠if-else if-...-else序列可以看作是由互斥选择项组成的选择结构. 21.有时, 要想了解程序在某一方面的功能, 运行它可能比阅读源代码更为恰当. 22.在分析重要的程序时, 最好首先识别出重要的组成部分. 23.了解局部的命名约定, 利用它们来猜测变量和函数的功能用途. 24.当基于猜测修改代码时, 您应该设计能够验证最初假设的过程. 这个过程可能包括用编译器进行检查|引入断言|或者执行适当的测试用例. 25.理解了代码的某一部分, 可能帮助你理解余下的代码. 26.解决困难的代码要从容易的部分入手. 27.要养成遇到库元素就去阅读相关文档的习惯; 这将会增强您阅读和编写代码的能力. 28.代码阅读有许多可选择的策略: 自底向上和自顶向下的分析|应用试探法和检查注释和外部文档, 应该依据问题的需要尝试所有这些方法. 29.for (i=0; i

android开发计算器课程设计样本

Android应用程序开发 实验报告 学号： 学生姓名：冯会会 指引教师：齐兵辉 提交时间： .11.10

目录 第一章系统分析与设计..................................................................................... 错误!未定义书签。 1.1系统可行性分析............................................................................................. 错误!未定义书签。 1.2系统需求分析 ................................................................................................ 错误!未定义书签。第二章系统详细设计 ........................................................................................ 错误!未定义书签。 2.1 ACTIVITY详细设计............................................................................................. 错误!未定义书签。 2.2 XML文献详细设计........................................................................................... 错误!未定义书签。第三章测试运营及总结..................................................................................... 错误!未定义书签。 3.1界面截图 ........................................................................................................ 错误!未定义书签。 3.2运营界面截图 ................................................................................................ 错误!未定义书签。 3.3运营成果截图................................................................................................. 错误!未定义书签。 3.4总结 ................................................................................................................ 错误!未定义书签。

如何看懂源代码--(分析源代码方法)

如何看懂源代码--(分析源代码方法) 4 推 荐 由于今日计划着要看Struts 开源框架的源代码 昨天看了一个小时稍微有点头绪,可是这个速度本人表示非常不满意,先去找了下资 料, 觉得不错... 摘自(繁体中文 Traditional Chinese):http://203.208.39.132/translate_c?hl=zh-CN&sl=en&tl=zh-CN&u=http://ww https://www.wendangku.net/doc/157958934.html,/itadm/article.php%3Fc%3D47717&prev=hp&rurl=https://www.wendangku.net/doc/157958934.html,&usg=AL kJrhh4NPO-l6S3OZZlc5hOcEQGQ0nwKA 下文为经过Google翻译过的简体中文版: 我们在写程式时，有不少时间都是在看别人的代码。 例如看小组的代码，看小组整合的守则，若一开始没规划怎么看，就会“噜看噜苦（台语）”不管是参考也好，从开源抓下来研究也好，为了了解箇中含意，在有限的时间下，不免会对庞大的源代码解读感到压力。网路上有一篇关于分析看代码的方法，做为程式设计师的您，不妨参考看看，换个角度来分析。也能更有效率的解读你想要的程式码片段。 六个章节： （ 1 ）读懂程式码，使心法皆为我所用。（ 2 ）摸清架构，便可轻松掌握全貌。（ 3 ）优质工具在手，读懂程式非难事。（ 4 ）望文生义，进而推敲组件的作用。（ 5 ）找到程式入口，再由上而下抽丝剥茧。（ 6 ）阅读的乐趣，透过程式码认识作者。 程式码是别人写的，只有原作者才真的了解程式码的用途及涵义。许多程式人心里都有一种不自觉的恐惧感，深怕被迫去碰触其他人所写的程式码。但是，与其抗拒接收别人的程式码，不如彻底了解相关的语言和惯例，当成是培养自我实力的基石。 对大多数的程式人来说，撰写程式码或许是令人开心的一件事情，但我相信，有更多人视阅读他人所写成的程式码为畏途。许多人宁可自己重新写过一遍程式码，也不愿意接收别人的程式码，进而修正错误，维护它们，甚至加强功能。 这其中的关键究竟在何处呢？若是一语道破，其实也很简单，程式码是别人写的，只有原作者才真的了解程式码的用途及涵义。许多程式人心里都有一种不自觉的恐惧感，深怕被迫去碰触其他人所写的程式码。这是来自于人类内心深处对于陌生事物的原始恐惧。 读懂别人写的程式码，让你收获满满 不过，基于许多现实的原因，程式人时常受迫要去接收别人的程式码。例如，同事离职了，必须接手他遗留下来的工作，也有可能你是刚进部门的菜鸟，而同事经验值够了，升级了，风水轮流转，一代菜鸟换菜鸟。甚至，你的公司所承接的专案，必须接手或是整合客户前一个厂商所遗留下来的系统，你们手上只有那套系统的原始码（运气好时，还有数量不等的文件）。 诸如此类的故事，其实时常在程式人身边或身上持续上演着。许多程式人都将接手他人的程式码，当做一件悲惨的事情。每个人都不想接手别人所撰写的程式码，因为不想花时间去探索，宁可将生产力花在产生新的程式码，而不是耗费在了解这些程式码上。