精华内容
下载资源
问答
  • IO端口和IO内存区别

    2014-05-19 02:59:24
    例如:Intel x86平台普通使用了名为内存映射(MMIO)的技术,该技术是PCI规范的一部分,IO设备端口被映射到内存空间,映射后,CPU访问IO端口就如同访问内存一样。 外设IO寄存器地址统一编址的CPU,这时应该称外设...
  • 外设IO寄存器地址独立编址的CPU,这时应该称外设IO寄存器为IO端口,访问IO寄存器可通过ioport_map将其映射 到虚拟地址空间,但实际上这是给开发人员制造的... 例如:Intel x86平台普通使用了名为内存映射(MMIO)的技

        外设IO寄存器地址独立编址的CPU,这时应该称外设IO寄存器为IO端口,访问IO寄存器可通过ioport_map将其映射 到虚拟地址空间,但实际上这是给开发人员制造的一个“假象”,并没有映射到内核虚拟地址,仅仅是为了可以使用和IO内存一样的接口访问IO寄存器;也可以 直接使用in/out指令访问IO寄存器。

        例如:Intel x86平台普通使用了名为内存映射(MMIO)的技术,该技术是PCI规范的一部分,IO设备端口被映射到内存空间,映射后,CPU访问IO端口就如同访问内存一样。

        外设IO寄存器地址统一编址的CPU,这时应该称外设IO寄存器为IO内存,访问IO寄存器可通过ioremap将其映射到虚拟地址空间,然后再使用read/write接口访问。

    展开全文
  • IO内存和IO端口的主要区别是,IO端口操作具有边际效应,而内存则没有(所以可以用多种方法进行优化,比如重新排序、告诉缓存等)。   使用IO内存前要先申请request_mem_region,然后ioremap映射;使用

    IO端口是指接口电路中能够被CPU直接访问的寄存器,一般有数据端口、控制端口和状态端口。每个连接到IO总线的设备都有自己的地址(集合),即端口,可以被映射到物理地址空间。

    IO内存和IO端口的主要区别是,IO端口操作具有边际效应,而内存则没有(所以可以用多种方法进行优化,比如重新排序、告诉缓存等)。

     

    使用IO内存前要先申请request_mem_region,然后ioremap映射;使用IO port前要用request_region请求。Linux维护全局变量ioport_resource和iomem_resource,每次request的时候从其中分配。PCI设备所需的内存基址在启动的时候已经有BIOS设定,所以在driver中需request_mem_region(base,length)声明。

    request_region和request_mem_region仅仅申请资源。io region为0~64k,mem为0~4G。申请后仅该驱动程序可以使用该资源。

     

    request_mem_region 函数返回resource指针,ioremap函数将该物理地址映射成内核虚拟地址(内部用vm_struct组织,跟vmalloc类似)。

    ioport_map用于将io port映射成内核虚拟地址。

    展开全文
  • 【Java基础】IO、NIO

    2019-05-11 14:32:20
    目录 IO File类 ...利用直接缓冲区完成文件的赋值(内存映射文件) 通道之间的数据传输(直接缓冲区) 分散(Scatter)聚集(Gather) 2、Buffer(缓冲) 类型、方法、属性 示例: 3...

    目录

    IO

    File类

    IO原理

    流的分类:

    NIO(New IO)

    NIO与IO区别

    阻塞与非阻塞:

    NIO核心:

    1、Channel(通道)

    利用通道完成文件的复制(非直接缓冲区)

    利用直接缓冲区完成文件的赋值(内存映射文件)

    通道之间的数据传输(直接缓冲区)

    分散(Scatter)和聚集(Gather)

    2、Buffer(缓冲)

    类型、方法、属性

    示例:

    3、Selector(选择器)


    IO

    IO:Blocking IO 同步阻塞

    使用输入机制,允许程序读取外部数据(包括俩字磁盘、光盘等存储设备的数据)、用户输入数据

    使用输出机制,允许程序记录运行状态,将程序数据输出到磁盘、光盘等存储设备中。

    File类

    IO原理

    IO流用来处理设备之间的数据传输。

    Java程序中,对于数据的输入/输出操作以“流(stream)”的方式进行。

     

    流的分类:

     

    Java使用处理流来包装节点流是一种典型的装饰器设计模式。

    NIO(New IO)

     

    NIO与IO区别

    阻塞与非阻塞:

     

     

    NIO核心:

    若使用NIO系统,需要获取用于连接IO设备的通道一级用于容纳数据的缓冲区。然后操作缓冲区,对数据进行处理。

    采用内存映射文件的方式来处理输入/输出。将文件或文件的一段区域映射到内存中,这样就可以像访问内存一样来访问文件了,这种方式比传统的要快。

    Channel负责传输,Buffer负责存储。Channel类似于铁路,Buffer类似于火车。

    1、Channel(通道)

    类似于:铁路

    通道表示打开IO设备(例如:文件、套接字)的连接。Channel本身不存储数据,只能与Buffer进行交互。

    所有数据都需要通过通道传输;Channel与传统的InputStream、OutputStream的最大区别在于:它提供了一个map()方法,通过该map()方法可以直接将“一块数据”映射到内存中。如果传统的面向流,则NIO面向块的处理。

     

    利用通道完成文件的复制(非直接缓冲区)

    // 利用通道完成文件的复制(非直接缓冲区)
        @Test
        public void test2() throws IOException {
    
            
            FileInputStream fis = null;
            FileOutputStream fos = null;
    
            // 获取通道
            FileChannel inChannel = null;
            FileChannel outChannel = null;
    
            try {
                fis = new FileInputStream("G:\\学习资料2019\\nio\\1.jpg");
                fos = new FileOutputStream("2.jpg");
    
                // 获取通道
                inChannel = fis.getChannel();
                outChannel = fos.getChannel();
    
                // 分配指定大小的缓冲区
                ByteBuffer buf = ByteBuffer.allocate(1024);
    
                // 将通道中的数据存入缓冲区
                while (inChannel.read(buf) != -1) {
                    buf.flip(); // 切换读取数据的模式
                    // 将缓冲区中的数据写入通道中
                    outChannel.write(buf);
                    buf.clear();// 清空缓存区
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outChannel != null) {
                    try {
                        outChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                if (inChannel != null) {
                    try {
                        inChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }

    利用直接缓冲区完成文件的赋值(内存映射文件)

    // 使用直接缓冲区完成文件的复制(内存映射文件)
        @Test
        public void test3() throws IOException{
            long start = System.currentTimeMillis();
            FileChannel inChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.READ);
            FileChannel outChannel = FileChannel.open(Paths.get("3.jpg"), StandardOpenOption.WRITE,StandardOpenOption.READ, StandardOpenOption.CREATE);
            // 内存映射文件
            MappedByteBuffer inMappedBuf = inChannel.map(FileChannel.MapMode.READ_ONLY,0,inChannel.size());
            MappedByteBuffer outMappedBuf = outChannel.map(FileChannel.MapMode.READ_WRITE,0,inChannel.size());
    
            // 直接对缓冲区进行数据的读写操作
            byte[] dst = new byte[inMappedBuf.limit()];
            inMappedBuf.get(dst);
            outMappedBuf.put(dst);
    
            inChannel.close();
            outChannel.close();
            long end = System.currentTimeMillis();
            System.out.println(end - start);
        }

    通道之间的数据传输(直接缓冲区)

       // 通道之间的数据传输
        @Test
        public void test4() throws IOException {
            FileChannel inChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.READ);
            FileChannel outChannel = FileChannel.open(Paths.get("5.jpg"), StandardOpenOption.WRITE,StandardOpenOption.READ, StandardOpenOption.CREATE);
    
            //        inChannel.transferTo(0,inChannel.size(),outChannel);
            outChannel.transferFrom(inChannel,0,inChannel.size());
            inChannel.close();
            outChannel.close();
        }

    分散(Scatter)和聚集(Gather)

     

     

    分散读取:

     @Test
        public void test5() throws IOException{
            RandomAccessFile raf1 = new RandomAccessFile("1.txt","rw");
    
            // 获取通道
            FileChannel channel =  raf1.getChannel();
    
            // 分配指定大小的缓冲区
            ByteBuffer buf1 = ByteBuffer.allocate(1);
            ByteBuffer buf2 = ByteBuffer.allocate(1024);
    
            // 分散读取
            ByteBuffer[] bufs = {buf1,buf2};
            channel.read(bufs);
    
            for (ByteBuffer byteBuffer:bufs
                 ) {
                byteBuffer.flip();
            }
            System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));;
            System.out.println("-------------------------------");
            System.out.println(new String (bufs[1].array(),0,bufs[1].limit()));
        }

    聚集写入:

     @Test
        public void test5() throws IOException{
            RandomAccessFile raf1 = new RandomAccessFile("1.txt","rw");
    
            // 获取通道
            FileChannel channel =  raf1.getChannel();
    
            // 分配指定大小的缓冲区
            ByteBuffer buf1 = ByteBuffer.allocate(1);
            ByteBuffer buf2 = ByteBuffer.allocate(1024);
    
            // 分散读取
            ByteBuffer[] bufs = {buf1,buf2};
            channel.read(bufs);
    
            for (ByteBuffer byteBuffer:bufs
                 ) {
                byteBuffer.flip();
            }
            System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));;
            System.out.println("-------------------------------");
            System.out.println(new String (bufs[1].array(),0,bufs[1].limit()));
    
            // 聚集写入
            RandomAccessFile raf2 = new RandomAccessFile("2.txt","rw");
            FileChannel channel2 = raf2.getChannel();
    
            channel2.write(bufs);
        }

     

    2、Buffer(缓冲)

    类似于:火车

    负责数据的存取。

    可以理解成一个容器,本质是一个数组,发送到Channel中的所有对象都必须首先放到Buffer中,从而Channel中读取的数据也必须先放到Buffer中。

    Buffer可以一次次去Channel中共取数据,也允许Channel直接将文件的某块数据映射成Buffer。

    类型、方法、属性

     

    示例:

      @Test
        public void test1() {
            System.out.println("--------------allocate-------------------");
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
            System.out.println("-----------------put----------------");
            // 利用put存入数据到缓冲区
            String str = "abcde";
            byteBuffer.put(str.getBytes());
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
            System.out.println("-----------------flip()----------------");
            // 切换到读取数据的模式
            byteBuffer.flip();
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
            System.out.println("-----------------get()----------------");
            // 利用get()读取缓冲区中的数据
            byte[] bytes = new byte[byteBuffer.limit()];
            byteBuffer.get(bytes);
            System.out.println(new String(bytes, 0, bytes.length));
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
            System.out.println("-----------------rewind()----------------");
            // 可重复读数据
            byteBuffer.rewind();
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
            System.out.println("-----------------clear()----------------");
            // clear()清空缓冲区,但是缓冲区中的数据依然存在,但是处于“被遗忘状态”,不能正确的读取数据
            byteBuffer.clear();
            System.out.println(byteBuffer.capacity());
            System.out.println(byteBuffer.limit());
            System.out.println(byteBuffer.position());
    
    
        }
    

    3、Selector(选择器)

     

    展开全文
  • java IO、 NIO面试题

    万次阅读 2018-01-30 17:01:06
    Java 中,直接缓冲区与非直接缓冲器有什么区别 ...直接缓冲区:内核地址空间用户地址空间之间形成了一个物理内存映射文件,减少了之间的copy过程。 存在风险:用户不易控制、GC 非直接缓冲区:通过allo
    1. Java 中,直接缓冲区与非直接缓冲器有什么区别
      物理磁盘->内核地址空间->用户地址空间->应用程序
      OS -> JVM

    直接缓冲区:内核地址空间和用户地址空间之间形成了一个物理内存映射文件,减少了之间的copy过程。

    存在风险:用户不易控制、GC

    非直接缓冲区:通过allocate()分配缓冲区,将缓冲区建立在JVM的内存中
    这里写图片描述
    直接缓冲区:通过allocateDirect()分配直接缓冲区,将缓冲区建立在物理内存中,可以提高效率。
    这里写图片描述

    1. Java 中的内存映射缓存区是什么?
    2. Java 中,ByteBuffer 与 StringBuffer有什么区别
    展开全文
  • 这种的话就是Windows内部给做内存映射, 所以相对比缓冲区方式的话就快多了. 款式也是上一篇一样了, 就是还是模拟写入文件读取文件的款式, 没有什么太大的区别, 主要的区别是内核这边操作方式不...
  • 通道4.1 Java 为 Channel 接口提供的最主要实现类4.2 利用通道完成文件的复制(非直接缓冲区)4.3 使用直接缓冲区完成文件的复制(内存映射文件) 1.Java NIO简介 Java NIO(New IO)是从Java 1.4版本开始引入的一个新...
  • 二、NIO

    2020-03-10 17:04:03
    文章目录NIO简介NIO传统IO区别通道缓冲区缓冲区缓冲区中的四个核心属性flip()直接缓冲区与非直接缓冲区通道通道的主要的实现类利用通道完成文件的复制使用直接缓冲区完成文件的复制(内存映射文件)通道之间的文件...
  • RocketMQ零拷贝原理零拷贝原理PageCachecache和buffer的区别HeapByteBuffer和DirectByteBuffer缓冲IO和直接IO内存映射文件(Mmap)直接内存读取并发送文件的过程Mmap读取并发送文件的过程Sendfile零拷贝读取并发送...
  • 零拷贝原理

    2021-03-25 14:52:26
    4 缓冲IO和直接IO 5 内存映射文件(Mmap) 6 、直接内存读取并发送文件的过程 7 、Mmap读取并发送文件的过程 8 、Sendfile零拷贝读取并发送文件的过程 零拷贝(zero copy)小结 #综述 Page cache是通过将磁盘...
  • Channel(通道)Buffer(缓冲)是新IO(NIO)的核心两个对象。  Channel(通道)   Channel与传统的InputStream、OutputStream最大区别在于:  Channel提供了map()方法,可以直接把"一块数据"映射内存,将...
  • 深信服面试记录 2017

    千次阅读 2017-07-26 16:16:50
    深信服面试记录 电话面了接近40分钟,对于自己简历上写的东西一定要清清楚楚明明白白,切勿模棱两可!!!1.线程的通信方式。...直接读取磁盘和内存映射区别。虚拟内存是否涉及IO操作。 5.socket并发
  • I/O(二)—— NIO

    2021-01-25 21:49:18
    NIO在基础的IO流上发展处新的特点,分别是:内存映射技术,字符及编码,非阻塞I/O文件锁定。 Channel(通道)Buffer(缓冲)是NIO中的两个核心对象。 Channel类似于传统IO中的流对象,其与InputStream...
  • 第01节、阻塞IO与非阻塞IO区别 第02节、NIO客户端与服务器端 第03节、Netty框架介绍 第04节、Netty服务器端 第05节、Netty客户端 第06节、总结 资料+源码.rar 0011-蚂蚁课堂(每特学院)-2期-Netty高级 第01节、长...
  • java NIO 入门学习

    2013-12-04 10:23:12
    Channel(通道)Buffer(缓冲)是新IO中的两个核心对象,Channel是对传统的输入/输出系统的模拟,在新IO系统中,所有的数据都需要通过通道传输:Channel与传统的InputStream,OutputStream最大的区别在于它提供了一个...
  • 读核感悟 kbuild系统 编译到内核编译成模块的区别 24 读核感悟 kbuild系统 make bzImage的过程 26 读核感悟 kbuild系统 make menuconfig 31 读核感悟 文件系统 用C来实现面向对象 32 读核感悟 设计模式 用C来实现...
  • java为数据结构中的映射定义一个接口java.util.Map,有四个实现类HashMap Hashtable LinkedHashMap TreeMap用法和区别;对Map排序; 5字符串 使用String;判断一个字符串是否是合法的java标识符;使用StringBuffer;...
  •  ArrayList Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,...
  • java 面试题 总结

    2009-09-16 08:45:34
    ArrayListVector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector...
  • SSO-WebDemo

    2013-08-12 20:25:57
    这样的方式大大区别于传统的(Client/Server)C/S结构,在那样的应用中,客户端服务器端会建立一个长时间的专用的连接通道。正是因为有了无状态的特性,每个连接资源能够很快被其他客户端所重用,一台Web服务器才...
  • 内存限制,当前大字库可支持到 32*32,中文小字库可支持到 40*40. 2.不再支持 vga 图形模式。 2015-07-07(yaya) 1.支持每像素16位彩色模式(64K 5:6:5)。 2.支持 jpg(jpeg,jpe)图像格式。 3.在 vbe ...
  • 14 在虚拟存储器中,当程序正在执行时,()完成地址映射。 A:程序员 B:编译器 C:装入程序 D:操作系统 15 A:ROMSRAM B:DRAMSRAM C:ROMDRAM D:ROMCD-ROM 16 在计算机的专业术语中,ROM表示( )。 A:外...
  • //查看内存信息两部曲: # lsdev -C | grep mem mem0 Available 00-00 Memory # lsattr -El mem0 size 1024 Total amount of physical memory in Mbytes False goodsize 1024 Amount of usable physical memory in ...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

内存映射和直接io区别