下载 >  课程资源 >  专业指导 > SDT处理器
0分

SDT处理器

含SDT编译器和SDT文件处理器
2007-08-01 上传大小:216KB
立即下载 开通VIP
分享
收藏 举报
时代通 SDT-550写频软件

时代通 SDT-550写频软件深圳时代电子设备有限公司 Electronics Co.,Ltd SDT-550 对讲机编程软件 SDT-550 Radio Software

立即下载
3积分/C币
MiniSDT编译器-1.1.9

SDT语言是用来描述各种各样结构化文档的脚本语言,它的目标是为普通用户提供一个稳定的、可扩展的平台,解析形形色色的文档,包括二进制和文本。<br>当前的版本经过了大量的测试,压缩包内包含以下内容:<br>SDTParsor.exe --SDT语言编译器、文件处理器<br>SDT.ini --SDT批处理配置文件<br>samples --包含数据样本<br>doc --包含测试总结、使用技巧、SDT语法说明、升级记录

立即下载
3积分/C币
SDT样例

包含用SDT语法描述的源文件和模版文件(*.SDT)

立即下载
3积分/C币
pspice教程(附常用函数)

熟悉其防真功能,掌握各种仿真的参数设置 希望大家能用上

立即下载
3积分/C币
SDT测试版

SDT测试版,包含样例

立即下载
3积分/C币
SDT语法简介-1.1.2

SDT语言语法简介-1.1.2

立即下载
3积分/C币
Big-Sticky-Notes-master

SDT php conding guide

立即下载
0积分/C币
Eclipse SDT

用于解决在Eclipse中安装ADT20.0.3插件时出现的“org.eclipse.cdt.feature.group 0.0.0' but it could not be found”错误。

立即下载
3积分/C币
SDT语法规则-0.9.8

SDT语法规则-0.9.8

立即下载
3积分/C币
delphi 的USB设备读写(HID)

delphi 整理的一个 HID 硬件的USB接口的读写程序,经过delphi6 windows2003测试通过。

立即下载
50积分/C币
冰刃源代码,揭示驱动层的秘密,hook

冰刃源代码,过滤,hook,挂载SDT,监控

立即下载
3积分/C币
射频卡读卡器SDT

13.56M射频卡读写器SDT系列 开发文档

立即下载
10积分/C币
psi search

对pat,pmt,sdt,bat,nit,解析

立即下载
0积分/C币
嵌入式开发工具SDT

嵌入式ARM开发工具SDT,破解版的。绝对物有所值。

立即下载
3积分/C币
操作原理 设备的添加申请删除和归还

// device.cpp : Defines the entry point for the console application. 什么时候不能删除设备 // //#include &quot;stdafx.h&quot; #include &quot;stdio.h&quot; #include &quot;stdlib.h&quot; #include &quot;string.h&quot; #include &quot;iostream.h&quot; //定义“空” #define null 0 //定义“进程”结构体 struct process { char process_name[10]; char apply_deviceid; struct process *next; }; //定义“系统设备表”结构体(项) struct SDT_item { char device_id; struct DCT *SDT_dct; //设备驱动程序入口 }SDT[20]; //定义“设备控制表”结构体 struct DCT { //char device_type; char device_id; int device_state; struct COCT *DCT_coct; int times; struct process *DCT_queue; }*device_K, *device_M, *device_T, *device_P; //定义“控制器控制表”结构体 struct COCT { char controller_id; int controller_state; struct CHCT *COCT_chct; struct process *COCT_queue; }*COCTS[10], *COCT1, *COCT2, *COCT3; //定义“通道控制表”结构体 struct CHCT { char channel_id; int channel_state; char use_device; struct process *CHCT_queue; }*CHCT1, *CHCT2; void init() { //初始化“设备控制表(DCT)” device_K = (struct DCT *)malloc(sizeof(struct DCT)); device_M = (struct DCT *)malloc(sizeof(struct DCT)); device_T = (struct DCT *)malloc(sizeof(struct DCT)); device_P = (struct DCT *)malloc(sizeof(struct DCT)); COCT1 = (struct COCT *)malloc(sizeof(struct COCT)); COCT2 = (struct COCT *)malloc(sizeof(struct COCT)); COCT3 = (struct COCT *)malloc(sizeof(struct COCT)); CHCT1 = (struct CHCT *)malloc(sizeof(struct CHCT)); CHCT2 = (struct CHCT *)malloc(sizeof(struct CHCT)); device_K-&gt;device_id = 'K'; device_K-&gt;device_state = 0; device_K-&gt;DCT_coct = COCT1; device_K-&gt;times = 0; device_K-&gt;DCT_queue = null; device_M-&gt;device_id = 'M'; device_M-&gt;device_state = 0; device_M-&gt;DCT_coct = COCT1; device_M-&gt;times = 0; device_M-&gt;DCT_queue = null; device_T-&gt;device_id = 'T'; device_T-&gt;device_state = 0; device_T-&gt;DCT_coct = COCT2; device_T-&gt;times = 0; device_T-&gt;DCT_queue = null; device_P-&gt;device_id = 'P'; device_P-&gt;device_state = 0; device_P-&gt;DCT_coct = COCT3; device_P-&gt;times = 0; device_P-&gt;DCT_queue = null; //初始化“系统设备表(SDT)” SDT[0].device_id = 'K'; SDT[0].SDT_dct = device_K; SDT[1].device_id = 'M'; SDT[1].SDT_dct = device_M; SDT[2].device_id = 'T'; SDT[2].SDT_dct = device_T; SDT[3].device_id = 'P'; SDT[3].SDT_dct = device_P; //初始化“控制器控制表(COCT)” COCT1-&gt;controller_id = '1'; COCT1-&gt;controller_state = 0; COCT1-&gt;COCT_chct = CHCT1; COCT1-&gt;COCT_queue = null; COCT2-&gt;controller_id = '2'; COCT2-&gt;controller_state = 0; COCT2-&gt;COCT_chct = CHCT2; COCT2-&gt;COCT_queue = null; COCT3-&gt;controller_id = '3'; COCT3-&gt;controller_state = 0; COCT3-&gt;COCT_chct = CHCT2; COCT3-&gt;COCT_queue = null; COCTS[0] = COCT1; COCTS[1] = COCT2; COCTS[2] = COCT3; //初始化“通道控制表(CHCT)” CHCT1-&gt;channel_id = '1'; CHCT1-&gt;channel_state = 0; CHCT1-&gt;use_device = '0'; CHCT1-&gt;CHCT_queue = null; CHCT2-&gt;channel_id = '2'; CHCT2-&gt;channel_state = 0; CHCT2-&gt;use_device = '0'; CHCT2-&gt;CHCT_queue = null; } void add_device() { struct DCT *dct_temp; struct COCT *coct_temp; char yes, coct_choice, chct_choice; dct_temp = (struct DCT *)malloc(sizeof(struct DCT)); printf(&quot;请输入设备的标识符:&quot;); cin&gt;&gt;dct_temp-&gt;device_id; //判断设备重名 int m=0; for(m=0; m&lt;20; m++){ if(SDT[m].device_id == dct_temp-&gt;device_id){ printf(&quot;系统中已有标识符为 %c 的设备,请重新操作!\n&quot;, dct_temp-&gt;device_id); break; } } if(m == 20){ dct_temp-&gt;device_state = 0; dct_temp-&gt;DCT_coct = null; dct_temp-&gt;times = 0; dct_temp-&gt;DCT_queue = null; //添加SDT[]表项 for(int k=0;k&lt;20;k++){ if(SDT[k].SDT_dct == null){ SDT[k].device_id = dct_temp-&gt;device_id; SDT[k].SDT_dct = dct_temp; break; } } printf(&quot;是否利用原有的COCT?(Y/N)&quot;); cin&gt;&gt;yes; if(yes == 'Y' || yes == 'y'){ printf(&quot;目前系统中存在的COCT有:\n&quot;); for(int i=0; i&lt;10; i++){ if(COCTS[i] != null){ printf(&quot;%c &quot;, COCTS[i]-&gt;controller_id); } } printf(&quot;\n请选择你想使用的COCT(标识符):&quot;); cin&gt;&gt;coct_choice; for(int l=0; l&lt;10; l++){ if(coct_choice == COCTS[l]-&gt;controller_id){ dct_temp-&gt;DCT_coct = COCTS[l]; break; } } }else if(yes == 'N' || yes == 'n'){ printf(&quot;请输入COCT的标识符:&quot;); coct_temp = (struct COCT *)malloc(sizeof(struct COCT)); cin&gt;&gt;coct_temp-&gt;controller_id; //初始化coct_temp coct_temp-&gt;controller_state = 0; coct_temp-&gt;COCT_chct = null; coct_temp-&gt;COCT_queue = null; for(int j=0; j&lt;10; j++){ if(COCTS[j] == null){ COCTS[j] = coct_temp; break; } } printf(&quot;请选择你想使用的CHCT(标识符):(1/2)&quot;); cin&gt;&gt;chct_choice; if(chct_choice == '1'){ coct_temp-&gt;COCT_chct = CHCT1; }else if(chct_choice == '2'){ coct_temp-&gt;COCT_chct = CHCT2; }else{ printf(&quot;通道输入选择错误&quot;); } dct_temp-&gt;DCT_coct = coct_temp; }else{ printf(&quot;错误输入&quot;); } } } void delete_device() { char device; printf(&quot;目前系统中有设备:\n&quot;); for(int i=0; i&lt;20; i++){ if(SDT[i].SDT_dct != null){ printf(&quot;%c &quot;, SDT[i].SDT_dct-&gt;device_id); } } printf(&quot;\n请选择你要删除的设备:&quot;); cin&gt;&gt;device; int flag = 0;//表示对应的COCT可以删 for(int j=0; j&lt;20; j++){ if(SDT[j].SDT_dct != null &amp;&amp; SDT[j].device_id == device){ for(int m=0; m&lt;20; m++){ if((SDT[m].SDT_dct != null) &amp;&amp; (m != j) &amp;&amp; (SDT[m].SDT_dct-&gt;DCT_coct-&gt;controller_id == SDT[j].SDT_dct-&gt;DCT_coct-&gt;controller_id)){ flag = 1;//表示对应的COCT不可以删 break; } } if(flag == 0){ for(int k=0; k&lt;10; k++){ if(COCTS[k]-&gt;controller_id == SDT[j].SDT_dct-&gt;DCT_coct-&gt;controller_id){ //删除对应的COCT COCTS[k] = null; break; } } SDT[j].SDT_dct-&gt;DCT_coct = null; } SDT[j].SDT_dct = null; SDT[j].device_id = '0'; } } } void apply_device() { char process[10], device; struct process *process_p, *process_apply; printf(&quot;请输入你要申请设备的进程名和设备标识符:&quot;); scanf(&quot;%s %c&quot;, process, &amp;device); //查找设备 for(int i=0; i&lt;20; i++){ if((SDT[i].SDT_dct != null) &amp;&amp; (SDT[i].device_id == device)){ //所申请的设备忙 if(SDT[i].SDT_dct-&gt;device_state == 1){ process_apply = (struct process *)malloc(sizeof(struct process)); strcpy(process_apply-&gt;process_name, process); process_apply-&gt;apply_deviceid = device; process_apply-&gt;next = null; if(SDT[i].SDT_dct-&gt;DCT_queue == null){ SDT[i].SDT_dct-&gt;DCT_queue = (struct process *)malloc(sizeof(struct process)); SDT[i].SDT_dct-&gt;DCT_queue = process_apply; }else{ process_p = SDT[i].SDT_dct-&gt;DCT_queue; while(process_p-&gt;next != null){ process_p = process_p-&gt;next; } process_p-&gt;next = process_apply; } printf(&quot;所申请的设备忙!,进程已经成功阻塞到设备 %c 下...\n&quot;, device); //所申请设备对应的控制器忙 }else if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state == 1){ process_apply = (struct process *)malloc(sizeof(struct process)); strcpy(process_apply-&gt;process_name, process); process_apply-&gt;apply_deviceid = device; process_apply-&gt;next = null; if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue == null){ SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue = (struct process *)malloc(sizeof(struct process)); SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue = process_apply; }else{ process_p = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue; while(process_p-&gt;next != null){ process_p = process_p-&gt;next; } process_p-&gt;next = process_apply; } //将对应的 设备状态置1 SDT[i].SDT_dct-&gt;device_state = 1; printf(&quot;所申请设备对应的控制器忙!,进程已经成功阻塞到控制器 %c 下...\n&quot;, SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_id); //所申请设备对应的通道忙 }else if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_state == 1){ process_apply = (struct process *)malloc(sizeof(struct process)); strcpy(process_apply-&gt;process_name, process); process_apply-&gt;apply_deviceid = device; process_apply-&gt;next = null; if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue == null){ SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue = (struct process *)malloc(sizeof(struct process)); SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue = process_apply; }else{ process_p = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue; while(process_p-&gt;next != null){ process_p = process_p-&gt;next; } process_p-&gt;next = process_apply; } //将对应的 控制器状态、设备状态均置1 SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 1; SDT[i].SDT_dct-&gt;device_state = 1; printf(&quot;所申请设备对应的通道忙!,进程已经成功阻塞到通道 %c 下...\n&quot;, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_id); //设备申请成功! }else{ SDT[i].SDT_dct-&gt;device_state = 1; SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 1; SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_state = 1; SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device = device; printf(&quot;进程%s 申请设备%c 成功...\n&quot;, process, device); } } } } void release_device(){ char device; struct process *process_p, *process_t; printf(&quot;请输入你要归还的设备标识符:&quot;); cin&gt;&gt;device; //查找设备 for(int i=0; i&lt;20; i++){ if((SDT[i].SDT_dct != null) &amp;&amp; (SDT[i].device_id == device)){ //察看所对应的通道队列是否为空 if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue == null){ //察看所对应的控制器队列是否为空 if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue == null){ int j=0; for(j=0; j&lt;20; j++){ if((SDT[j].SDT_dct != null) &amp;&amp; (SDT[j].SDT_dct-&gt;DCT_coct-&gt;controller_id == SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_id)){ if(SDT[j].SDT_dct-&gt;DCT_queue != null){ printf(&quot;进程 %s 已经被唤醒,并成功申请到设备 %c ...\n&quot;, SDT[j].SDT_dct-&gt;DCT_queue-&gt;process_name, SDT[j].SDT_dct-&gt;DCT_queue-&gt;apply_deviceid); SDT[j].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device = SDT[j].SDT_dct-&gt;DCT_queue-&gt;apply_deviceid; SDT[j].SDT_dct-&gt;DCT_queue = SDT[j].SDT_dct-&gt;DCT_queue-&gt;next; break; }else{ SDT[j].SDT_dct-&gt;device_state = 0; } } } if(j == 20){ SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_state = 0; SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 0; SDT[i].SDT_dct-&gt;device_state = 0; SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device = '0'; printf(&quot;当前没有对应于通道 %c 且处于阻塞状态的进程...\n&quot;, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_id); } //察看所对应的设备队列是否为空 }else{ if(SDT[i].SDT_dct-&gt;DCT_queue != null){ SDT[i].SDT_dct-&gt;device_state = 1; }else{ SDT[i].SDT_dct-&gt;device_state = 0; } printf(&quot;进程 %s 已经被唤醒,并成功申请到设备 %c ...\n&quot;, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue-&gt;process_name, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue-&gt;apply_deviceid); SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue-&gt;apply_deviceid; SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue-&gt;next; } }else{ if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_queue != null){ SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 1; SDT[i].SDT_dct-&gt;device_state = 1; }else if(SDT[i].SDT_dct-&gt;DCT_queue != null){ SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 1; SDT[i].SDT_dct-&gt;device_state = 1; }else{ SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state = 0; SDT[i].SDT_dct-&gt;device_state = 0; } printf(&quot;进程 %s 已经被唤醒,并成功申请到设备 %c ...\n&quot;, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue-&gt;process_name, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue-&gt;apply_deviceid); SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue-&gt;apply_deviceid; SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue = SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;CHCT_queue-&gt;next; } } } } void dispaly() { struct process *p; printf(&quot;系统中存在以下设备:\n&quot;); printf(&quot;SDT[i] DCT COCT CHCT 正使用设备\n\n&quot;); for(int i=0; i&lt;20; i++){ if(SDT[i].SDT_dct != null){ printf(&quot;%c %c(%d) %c(%d) %c(%d) &quot;, SDT[i].device_id, SDT[i].SDT_dct-&gt;device_id, SDT[i].SDT_dct-&gt;device_state, SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_id, SDT[i].SDT_dct-&gt;DCT_coct-&gt;controller_state, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_id, SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;channel_state); if(SDT[i].SDT_dct-&gt;DCT_coct-&gt;COCT_chct-&gt;use_device == SDT[i].device_id){ printf(&quot;&lt;&lt;---&quot;); } printf(&quot;\n&quot;); } } printf(&quot;\n&quot;); if(CHCT1-&gt;CHCT_queue != null){ printf(&quot;通道 1 下阻塞的进程有:&quot;); p = CHCT1-&gt;CHCT_queue; while(p != null){ printf(&quot;%s &quot;, p-&gt;process_name); p = p-&gt;next; } printf(&quot;\n&quot;); } if(CHCT2-&gt;CHCT_queue != null){ printf(&quot;通道 2 下阻塞的进程有:&quot;); p = CHCT2-&gt;CHCT_queue; while(p != null){ printf(&quot;%s &quot;, p-&gt;process_name); p = p-&gt;next; } printf(&quot;\n&quot;); } } int main(int argc, char* argv[]) { char operate; //对系统设备进行初始化 init(); printf(&quot;\n ----------- 操作系统实验三 -----------\n\n&quot;); dispaly(); while(1){ printf(&quot;请输入操作命令:&quot;); cin&gt;&gt;operate; switch(operate){ case 'a': add_device(); dispaly(); break; case 'd': delete_device(); dispaly(); break; case 's': apply_device(); dispaly(); break; case 'h': release_device(); dispaly(); break; default: printf(&quot;输入错误!请重新输入...\n&quot;); } } return 0; }

立即下载
3积分/C币
ADS1.2破解版安装包,亲测可运行

ADS1.2 ADS是ARM公司的集成开发环境软件,他的功能非常强大。他的前身是SDT,SDT是ARM公司几年前的开发环境软件,目前SDT早已经不再升级。ADS包括了四个模块分别是:SIMULATOR;C 编译器;实时调试器;应用函数库。

立即下载
5积分/C币
ads1.2的开发指南-带例程分析

ADS是ARM公司的集成开发环境软件,他的功能非常强大。他的前身是SDT,SDT是ARM公司几年前的开发环境软件,目前SDT早已经不再升级。ADS包括了四个模块分别是:SIMULATOR;C 编译器;实时调试器;应用函数库。

立即下载
3积分/C币
SDT算法及其在过程数据压缩中的应用

SDT算法及其在过程数据压缩中的应用

立即下载
3积分/C币
ARM SDT 2.5开发环境简介

熟悉ARM SDT 2.5开发环境,学会ARM并行口仿真器的使用

立即下载
3积分/C币
SDT编译器下载-1.1.2

包含编译器、样本文件

立即下载
3积分/C币
SDT资源下载-0.9.8

编译器、文件处理器、语法规格、样例

立即下载
3积分/C币
IPanel Dvb作业

解析ts流中的pat、pmt、sdt、nit信息

立即下载
3积分/C币
TS码流分析工具,TS PSI pat pmt sdt

TS码流分析工具,TS PSI pat pmt sdt

立即下载
3积分/C币
ARM开发软件使用教程

ARM开发软件使用教程 SDT 可以很快上手 非常不错的东东哦

立即下载
3积分/C币
TS文件找section

ts 分析 找section PMT PAT SDT TABLE psi si

立即下载
3积分/C币
神思二代win764位驱动

神思二代win764位驱动

立即下载
2积分/C币
NZJ5 PSI SI搜索系统 代码 nzj163 高压缩

里面有PAT/PMT/NIT/SDT/BAT等*.dat数据供解析

立即下载
3积分/C币
PSI/SI 入门技术手册

psi、si的入门技术手册,有码流分析,pat,sdt,pmt等表的介绍

立即下载
3积分/C币
大话处理器:处理器基础知识读本 清晰完全版电子书pdf

包含以下几个文件: 大话处理器(试读版).pdf 高清文字版 大话处理器:处理器基础知识读本.pdf 清楚扫描完全版 大话处理器v2.0.ppt ------------------------------------ 书名: 大话处理器 作者: 万木杨 ISBN: 9787302263159 出版社: 清华大学出版社 出版时间: 2011年10月29日 开本: 平装 语种: 简体中文 版次: 1 =================================================== 内容简介 处理器是IT、通信、电子产业的基石,没有处理器,信息产业大厦就如同建立在沙滩之上。 《大话处理器:处理器基础知识读本》是一本图文并茂、生动幽默的处理器科普读本,全书行文风趣幽默,用类比来解释晦涩的技术,用图画来代替枯燥的文字。本着科技以人为本的理念,《大话处理器:处理器基础知识读本》除了技术外,还介绍了大量人物和公司的故事,供大家闲读。 《大话处理器:处理器基础知识读本》的主要读者是IT、通信、电子、半导体行业的从业人员以及学生。喜欢技术的看技术,不喜欢技术的看故事。 =================================================== 目录 第1章 漫游计算机世界 1 1.1 计算机的前世、今生、来世 3 1.1.1 计算机的诞生 3 1.1.2 从军用到民用——飞入寻常百姓家 12 1.1.3 个人计算机时代——英雄辈出的时代 15 1.1.4 手机——装在口袋的计算机 25 1.1.5 无处不在的计算机 31 1.1.6 计算机的来世 31 1.2 计算机分门别类 33 1.3 PC机结构探秘 34 1.3.1 处理器——一颗奔腾的心 34 1.3.2 存储器——大肚能容,容天下难容之事 36 1.3.3 主板与芯片组——架起沟通的桥梁 38 1.3.4 输入设备——五觉 39 1.3.5 显示设备——脸面 42 1.3.6 显卡——我贵,因为我专业 47 1.3.7 通信接口——关节 47 1.3.8 软件——计算机的灵魂 49 1.3.9 计算机产业发展态势 50 第2章 初识处理器——掀起你的盖头来 53 2.1 处理器是怎样工作的——处理器的硬件模型 55 2.1.1 硬连线电路——一定终身 55 2.1.2 通用计算机模型——硬件搭台,软件唱戏 56 2.2 怎样来使用处理器——处理器的编程模型 57 2.2.1 软硬不分 57 2.2.2 ISA横插一刀 57 2.3 处理器的分层模型 58 2.4 选什么样的处理器——适合的才是最好的 59 2.4.1 硬件指标——硬实力的竞争 59 2.4.2 软件指标——软实力的竞争 62 2.4.3 商业指标——在商言商 63 第3章 指令集体系结构——处理器的外表 65 3.1 指令集是什么 67 3.1.1 从处理器编程模型谈起——一切从模型开始 67 3.1.2 计算机语言——人与计算机沟通的桥梁 68 3.2 指令集发展的来龙去脉 69 3.2.1 CISC时代——粗放式扩张 69 3.2.2 RISC时代——优化配置资源,合理提升效率 70 3.2.3 后RISC时代——不管黑猫白猫,抓到老鼠就是好猫 71 3.3 指令集的五朵金花 73 3.3.1 x86——硕大的大象 73 3.3.2 ARM——稳扎稳打的蚁群 74 3.3.3 MIPS——优雅的孔雀 75 3.3.4 Power——昔日的贵族 76 3.3.5 C6000——偏安一隅的独立王国 77 3.3.6 至今仍在服役的元老们 78 3.4 地盘之争 78 3.4.1 地盘划分 79 3.4.2 x86、ARM之战 80 3.4.3 ARM、MIPS之战 80 3.5 汇编语言格式——没有规矩不成方圆 81 3.5.1 机器字长 81 3.5.2 操作数个数 82 3.5.3 操作数顺序 83 3.5.4 大小端——小问题,大折腾 83 3.5.5 指令类型——我们需要哪些指令 83 3.5.6 寻址方式——千万里,我追寻着你 84 3.5.7 总结 85 第4章 微架构——处理器的内心世界 87 4.1 跟着顺溜学流水线 89 4.1.1 顺溜的2级流水线 89 4.1.2 顺溜流水线的深入分析 90 4.2 从子弹射击到指令执行 93 4.2.1 最简单的3级流水线 93 4.2.2 史上最经典的5级流水线 95 4.2.3 DSP更深的流水线 97 4.2.4 流水线上的冒险——免不了磕磕绊绊 98 4.2.5 分支预测——以古为镜,可以知兴替 103 4.3 从顺序执行到乱序执行——因时制宜 107 4.3.1 乱序的概念 107 4.3.2 指令的相关 108 4.3.3 去除指令的相关性 110 4.3.4 处理器的乱序执行 113 4.4 处理器并行设计——并行,提高性能的不二法门 117 4.5 指令并行(Instruction Level Parallelism) 118 4.5.1 指令并行的“绿营”和“蓝营” 118 4.5.2 Superscalar处理器实例——Intel P4 CPU 119 4.5.3 VLIW处理器实例——TI C6000 DSP 125 4.5.4 Superscalar和VLIW总结 130 4.6 数据并行(Data Level Parallelism) 130 4.6.1 何为SIMD、MMX、SSE 130 4.6.2 几种不同形式的SSE指令 132 4.7 线程并行(Thread Level Parallelism) 133 4.7.1 多线程——时分复用 133 4.7.2 硬件多线程——让我来帮你一把 135 4.7.3 多核——从“芯”到“蕊”的跳变 136 4.7.4 各种硬件多线程对比 138 4.8 并行总结 139 4.9 微架构总结 142 4.9.1 处理器性能公式 142 4.9.2 通过微架构的改进提高程序执行效率 142 4.9.3 商用处理器微架构的选择 143 第5章 Cache——处理器的“肚量” 145 5.1 什么是Cache——探索既熟悉又陌生的领域 147 5.1.1 随处可见的Cache——技术来源于生活 147 5.12 处理器的Cache——一切都是收益和成本的权衡 147 5.2 处理器的Cache结构——探索那些鲜为人知的秘密 150 5.2.1 Cache的层次——层次化管理 150 5.2.2 Cache的工作方式——丘比特之剑,命中与未命中 151 5.2.3 Cache的映射方式——多对一的策略 152 5.2.4 Cache的写方式——你不需要知道真相 156 5.3 Cache一致性 158 5.3.1 一致性问题的产生——信息不对称导致的问题 158 5.3.2 Cache一致性的底层操作 159 5.3.3 Cache一致性协议 160 5.4 片内可寻址存储器——软件管理的Cache 163 第6章 编写高效代码——时间就是生命 167 6.1 软件效率——21世纪什么最重要?效率! 169 6.1.1 高效代码的意义——时间就是生命,时间就是金钱 169 6.1.2 代码剖析——没有调查,就没有发言权 169 6.2 减少指令数——勤俭持家 171 6.2.1 使用更快的算法——算法,程序设计的灵魂 171 6.2.2 选用合适的指令——合适的人做合适的事 172 6.2.3 降低数据精度——比特也要省着用 173 6.2.4 减少函数调用——不要老打断我 173 6.2.5 空间换时间——我们总是在走,却忘了停留 174 6.2.6 减少过保护——打不破的部门墙 176 6.3 减少处理器不擅长的操作——不要逼我做我不喜欢的事情 176 6.3.1 少用乘法 177 6.3.2 少用除法、求余 177 6.3.3 在精度允许的条件下,将浮点数定点化 177 6.3.4 尽量减少分支 178 6.3.5 将最可能进入的分支放在 if中,而不是else中 179 6.4 优化内存访问——别让包袱拖垮了你 180 6.4.1 少使用数组,少使用指针 181 6.4.2 少用全局变量 181 6.4.3 一次多访问一些数据 182 6.4.4 数据对齐访问 182 6.4.5 大数据结构时的Cache line对齐 183 6.4.6 程序、数据访问符合Cache的时间、空间局部性 183 6.4.7 多线程编程时,避免false sharing 185 6.4.8 自己管理内存动态分配 185 6.4.9 隐藏数据搬移时间 186 6.5 充分利用编译器进行优化——编译器:我才是优化第一高手 187 6.5.1 编译器的结构——知己知彼,百战不殆 187 6.5.2 编译器提供了几级优化选项——分级管理 188 6.5.3 编译器会计算常量 188 6.5.4 简单的表达式化简 188 6.5.5 提取公共语句 189 6.5.6 循环展开、软件流水 190 6.5.7 自动向量化 190 6.5.8 高效的数据组织 191 6.5.9 指令并行化 191 6.5.10 编译器更懂处理器——百度更懂中文 192 6.6 利用多核来加速程序——人多力量大 193 6.6.1 并行计算 193 6.6.2 OpenMP 197 第7章 SOC——吸星大法 199 7.1 SOC大一统时代 201 7.1.1 SOC和IP 201 7.1.2 SOC市场驱动力 202 7.2 IP核 202 7.2.1 CPU IP 204 7.2.2 GPU IP 205 7.2.3 DSP IP 205 7.2.4 Video Engine IP 208 7.2.5 其他IP core 209 7.2.6 总结 210 第8章 “芯”路历程——明明白白我的“芯” 211 8.1 逻辑电路基础——计算机的基本构成 213 8.1.1 模拟、数字、逻辑的关系——细微之处探真知 213 8.1.2 组合逻辑电路——万丈高楼平地起 216 8.1.3 时序逻辑电路——你在我心中留下了记忆 219 8.1.4 微电子技术——微乎微乎,至于无形 221 8.2 芯片设计——芯者,国之大事,不可不察也 224 8.2.1 人类是怎么管理复杂事物的 224 8.2.2 芯片设计流程 227 8.2.3 硬件描述语言——软硬不分 227 8.2.4 逻辑综合 229 8.2.5 硬件描述语言与软件描述语言的差别 230 8.2.6 物理设计 231 8.3 芯片制造——点沙成金 233 8.3.1 探索微观世界 233 8.3.2 芯片制造流程 234

立即下载
50积分/C币
SDT参考 有关std 2.50

有关ARM Software Development的资料。英文版

立即下载
3积分/C币
关闭
img

spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip

资源所需积分/C币 当前拥有积分 当前拥有C币
5 0 0
点击完成任务获取下载码
输入下载码
为了良好体验,不建议使用迅雷下载
img

SDT处理器

会员到期时间: 剩余下载个数: 剩余C币: 剩余积分:0
为了良好体验,不建议使用迅雷下载
VIP下载
您今日下载次数已达上限(为了良好下载体验及使用,每位用户24小时之内最多可下载20个资源)

积分不足!

资源所需积分/C币 当前拥有积分
您可以选择
开通VIP
4000万
程序员的必选
600万
绿色安全资源
现在开通
立省522元
或者
购买C币兑换积分 C币抽奖
img

资源所需积分/C币 当前拥有积分 当前拥有C币
5 4 45
为了良好体验,不建议使用迅雷下载
确认下载
img

资源所需积分/C币 当前拥有积分 当前拥有C币
5 0 0
为了良好体验,不建议使用迅雷下载
VIP和C币套餐优惠
img

资源所需积分/C币 当前拥有积分 当前拥有C币
5 4 45
您的积分不足,将扣除 10 C币
为了良好体验,不建议使用迅雷下载
确认下载
下载
您还未下载过该资源
无法举报自己的资源

兑换成功

你当前的下载分为234开始下载资源
你还不是VIP会员
开通VIP会员权限,免积分下载
立即开通

你下载资源过于频繁,请输入验证码

您因违反CSDN下载频道规则而被锁定帐户,如有疑问,请联络:webmaster@csdn.net!

举报

若举报审核通过,可返还被扣除的积分

  • 举报人:
  • 被举报人:
  • *类型:
    • *投诉人姓名:
    • *投诉人联系方式:
    • *版权证明:
  • *详细原因: