精华内容
下载资源
问答
  • 行业分类-设备装置-一种基于FPGA的直接多块硬盘高速并行读写方法.zip
  • FileBatch类提供了一系列对批量并行读写操作支持(包括对FttpAdapter和FileAdapter),它跟并行读写的区别是不需要检查结果,会等到所有并行读写任务全部完成才返回,并在发生异常时提供事务补偿支持。   1、...

    FileBatch类提供了一系列对批量并行读写操作支持(包括对FttpAdapter和FileAdapter),它跟并行读写的区别是不需要检查结果,会等到所有并行读写任务全部完成才返回,并在发生异常时提供事务补偿支持。

     

    1、批量并行读:
    public Result<byte[]>[] readAllBatch(TryByteReadAdapter[] fras)
    实现对多个FttpReadAdapter任务的批量读,输入一个FttpReadAdapter数组,并行进行它们的读取,直到每个FttpReadAdapter读完后,以数组的方式批量输出它们对应的结果,比如:
    FttpReadAdapter[] fras = new FttpReadAdapter[3];
    fras[0]=new FttpAdapter(fttppath).getFttpReader(0,5);
    fras[1]=new FttpAdapter(fttppath).getFttpReader(5,5);
    fras[2]=new FttpAdapter(fttppath).getFttpReader(10,5);
    Result<byte[]>[] rs = new FileBatch().readAllBatch(fras);
    上面表示并行从3个位置读一个文件内容,等全部读完后,将对应的结果放在一个数组里返回

     

    2、批量并行写:
    FttpWriteAdapter[] fwas = new FttpWriteAdapter[3];
    fwas[0]=new FttpAdapter(fttppath).getFttpWriter(0,5);
    fwas[1]=new FttpAdapter(fttppath).getFttpWriter(5,5);
    fwas[2]=new FttpAdapter(fttppath).getFttpWriter(10,5);
    Result<Integer>[] rs = new FileBatch().writeBatch(fwas, "abcde".getBytes());
    上面表示并行对一个文件的3个位置写入“abcde”字符,等全部写完后,返回对应结果数组

    注意:这里跟并行读写一样,3个FttpReadAdapter或者FttpWriteAdapter是由3个不同的FttpAdapter生成,而不是同一个生成

     

    3、批量并行读写:
    Result<Integer>[] rs = new FileBatch().readWriteBatch(fras,fwas);
    表示将上面的批量读和批量写在一个过程中完成,从fras里每个FttpReadAdapter读,然后通过fwas里对应的每FttpWriteAdapter写入,所有读写完成后返回写入结果数组

     

    4、事务补偿处理:
    在批量并行读写过程中,如果其中一个FttpReadAdapter或者FttpWriteAdapter发生错误,那么框架会进行分布式事务处理,进行两阶段提交,然后调用undo操作进行事务补偿处理,撤消已经产生的改动和影响。

     

    FileBatch类提供了对undo方法的定义
    public Result[] undo(Result[] rtarr)
    rtarr是传入的结果,然后返回undo的撤消处理后的结果

    比如调用readAllBatch发生错误,FileBatch会将结果传入undo进行撤消操作,然后才返回结果
    因此开发者需要自己实现undo方法的内容,继承FileBatch类覆盖undo方法:
    public Result[] undo(Result[] rtarr){
    for(int i=0;i<rtarr.length;i++){
    if(rtarr[i].getStatus()==Result.EXCEPTION)
    System.out.println("Result index"+i+" Error");
    }

    return rtarr;
    }
    上面的undo方法将发生异常的结果的序号输出显示

     

    所有的批量读写方法都可以以排它的方式进行,指定boolean locked参数即可
    另外:除了byte批量并行读写外,也支持所有的整形批量并行读写,api和操作几乎类似

     

    FttpBatchWriteReadDemo演示了一个批量并行读、批量并行写、批量并行读写操作和事务补偿操作

     

    邮箱:Fourinone@yeah.net
    企鹅群:241116021
    demo源码指南及开发包下载地址:
    http://www.skycn.com/soft/68321.html

    展开全文
  • FttpAdapter是通过FttpReadAdapter的tryReadAll方法进行并行读 FttpAdapter fa = new FttpAdapter("fttp://10.232.20.151/home/log/1.log"); Result rs = fa.getFttpReader().tryReadAll(); 调用tryReadAll会立即...

    FttpAdapter是通过FttpReadAdapter的tryReadAll方法进行并行读
    FttpAdapter fa = new FttpAdapter("fttp://10.232.20.151/home/log/1.log");
    Result<byte[]> rs = fa.getFttpReader().tryReadAll();

    调用tryReadAll会立即返回一个Result<byte[]>,但是不能马上获取到结果值,需要轮循检查它的状态是否就绪
    rs.getStatus()有三种状态:
    Result.NOTREADY 未就绪
    Result.READY 就绪
    Result.EXCEPTION 异常

    轮循直到状态准备就绪:
    while(rs.getStatus()==Result.NOTREADY);

    状态就绪就可以通过getResult()获取到读取结果:
    byte[] bts = rs.getResult();

    可以对一个远程文件的不同部分同时并行读写,也可以对多个远程文件同时并行读写,比如:
    String fttppath = "fttp://10.232.20.151/home/log/1.log";
    FttpAdapter fa0 = new FttpAdapter(fttppath);
    FttpAdapter fa1 = new FttpAdapter(fttppath);
    FttpAdapter fa2 = new FttpAdapter(fttppath);
    Result<byte[]> rs0 = fa0.getFttpReader(0,5).tryReadAll();
    Result<byte[]> rs1 = fa1.getFttpReader(5,5).tryReadAll();
    Result<byte[]> rs2 = fa2.getFttpReader(10,5).tryReadAll();
    上面表示3个同时并行的读取,分别的从一个文件的0,5,10位置向后读5个字节。
    如果是并行写,则是:
    Result<Integer>[] rs0 = fa0.getFttpWriter(0,5).tryWrite("hello".getBytes());
    Result<Integer>[] rs1 = fa1.getFttpWriter(5,5).tryWrite("world".getBytes());
    Result<Integer>[] rs2 = fa2.getFttpWriter(10,5).tryWrite("fttp!".getBytes());

    注意:上面fa0,fa1,fa2是3个不同的FttpAdapter,而不是同一个FttpAdapter,否则后面的getFttpReader指定的读取范围会覆盖前面的范围,导致产生意外错乱。由于是对同一个远程文件并行读写,所以fa0,fa1,fa2的fttppath相同,如果对多个远程文件并行读写,则fttppath不同。

    FttpMulWriteReadDemo演示了并行对三个远程文件进行写,然后再并行进行读,在轮循状态时,如果就绪读取到结果后,将rs[i]设置为null表示不再重复检查。

    邮箱:Fourinone@yeah.net
    qq群:241116021
    demo源码指南及开发包下载地址:
    http://www.skycn.com/soft/68321.html

    展开全文
  • 并行flash FPGA读写测试,Verilog语言,可以实现并行flash读写单独测试。
  • LD3320并行串行读写辅助说明
  • 利用微机并行口实现IC卡读写控制的一种方法rar,并行口,IC卡,读写控制
  • socket 读写方法是否能并行处理? 也就是说 wirte 和 read分别放在不同的线程里并行。 这样可行不???
  • private static void SpiltFile(string srcFile, int portionSize) { string savedPath = @"\\stcsrv-c81\MMFeedHealthyDatacache\2016_07_10\Feedkeys\No_Process_test.txt"; File
     private static void SpiltFile(string srcFile, int portionSize)
            {
                string savedPath = @"\\stcsrv-c81\MMFeedHealthyDatacache\2016_07_10\Feedkeys\No_Process_test.txt";
                FileInfo fi = new FileInfo(srcFile);
                // total size in bytes
                Int64 size = fi.Length;
                object locker = new object();
                object writeLock = new object();
                List<MappedFile> mappedFiles = new List<MappedFile>();
                Int64 fileToRead = size;//文件总的大小
          
                portionSize = portionSize * 1024 * 1024; //每块大小
    
                Int64 portion = (Int64)Math.Ceiling(size * 1.0 / portionSize); //分成多少块
    
                Int64 fileOffset = 0;
    
                MemoryMappedViewAccessor mmf_reader = null;
                Stopwatch watch = Stopwatch.StartNew();
                watch.Start();
                Int64 fileSize = 0;
                using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(srcFile, FileMode.Open, "xyz", size))
                {
                    //using (var writeMap = MemoryMappedFile.CreateFromFile(savedPath, FileMode.Create, "test", size, MemoryMappedFileAccess.ReadWrite))
                    //{
                        //bool mutexCreated;
                        //Mutex mutex = new Mutex(true, "testmapmutex", out mutexCreated);//进程间同步
                        Parallel.For(0, portion, (i, ParallelLoopState) =>
                        {
    
                            //for (int i = 26; i < portion; i++)
                            //{
                            lock (locker)
                            {
                                fileSize = Math.Min(portionSize, fileToRead - portionSize * i);
                                if (fileSize > 0)
                                {
                                    byte[] buffer;
                                    using (mmf_reader = mmf.CreateViewAccessor(i * portionSize, fileSize, MemoryMappedFileAccess.Read))
                                    {
                                        buffer = new byte[fileSize];
                                        mmf_reader.ReadArray(0, buffer, 0, (int)fileSize);
                                        mappedFiles.Add(new MappedFile
                                        {
                                            Offset = i * portionSize, //fileOffset,
                                            Buffer = buffer,
                                            FileSize = fileSize
                                        });
                                    }
    
                                    //fileToRead -= fileSize;
                                    //lock (writeLock)
                                    //{
                                    //using (var writeMmf = MemoryMappedFile.OpenExisting("xyz"))
                                    //{
                                    //    using (var writeAccessor = writeMmf.CreateViewStream(i * portionSize, fileSize))
                                    //    {
                                    //        var w = new BinaryWriter(new FileStream(savedPath, FileMode.Create, FileAccess.Write));
                                    //        //writeAccessor.WriteArray(i * portionSize, buffer, 0, buffer.Length);
                                    //        //writeAccessor.Write(buffer, 0, buffer.Length);
                                    //        w.Write(buffer);
                                    //    }
                                    //}
    
                                    //using (MemoryMappedViewAccessor writeView = writeMap.CreateViewAccessor())
                                    //{
                                    //    writeView.WriteArray(i * portionSize, buffer, 0, (int)fileSize);
                                    //}
    
                                }
                                //}
                            }
    
                        });
                    }
    
    
                using (var writeMap = MemoryMappedFile.CreateFromFile(savedPath, FileMode.Create, "test", size, MemoryMappedFileAccess.ReadWrite))
                {
                    using (MemoryMappedViewAccessor writeView = writeMap.CreateViewAccessor())
                    {
                        Parallel.For(0, mappedFiles.Count, i =>
                        {
                            try
                            {
                                Monitor.Enter(locker);
                                writeView.WriteArray(mappedFiles[i].Offset, mappedFiles[i].Buffer, 0, (int)mappedFiles[i].FileSize);
                            }
                            catch (Exception)
                            {
    
                                throw;
                            }
                            finally
                            {
                                Monitor.Exit(locker);
                            }
    
                        });
                    }
                }
                watch.Stop();
                Console.WriteLine(watch.ElapsedMilliseconds);
                #region MyRegion
            }
        public class MappedFile
        {
            public long Offset { get; set; }
            public byte[] Buffer { get; set; }
            public long FileSize { get; set; }
        }


    展开全文
  • 8051单片机并行I/0口读写

    千次阅读 2013-07-08 15:40:11
    8051单片机并行I/0口读写 作者:佚名 文章来源:本站原创 点击数:338 更新时间:2011-08-10 前两天看资料,见到关于I/O口作为输入时,要先输出1的说明,有点迷惑。今天特意查了一些资料,费了半天劲,虽然还...

    8051单片机并行I/0口读写

    作者:佚名    文章来源:本站原创    点击数:338    更新时间:2011-08-10

    前两天看资料,见到关于I/O口作为输入时,要先输出1的说明,有点迷惑。今天特意查了一些资料,费了半天劲,虽然还没有完全弄明白,但也算也所收获,下面就列出来,以便将来查询并进一步补充。

       

                                ‍单片机锁存器电路原理图


    1、作为I/O口使用时,输入和输出原理。

    I/O口使用时,在控制信号的作用下,与门关闭,V1截止,同时多路开关打向下边,与锁存器的反向输出端Q^相连。

    输出数据时,“写锁存器”端发出脉冲,将“内部总线”上的数据写入输出锁存器,由Q^端控制V2,从而在引脚上反应出相应的状态。此种应用时P0端口各引脚应外接上拉电阻。

    输入数据时,分为读引脚和读端口两种方式。读端口的位置就是上图中的“读锁存器”,而读引脚则是上图中的“读引脚”。至于何时读端口,何时读引脚则是根据不同的指令由硬件自动完成的,这不需要我们操心。

    (附:读端口的指令:读端口的指令为端口内容取反这样的-修改-指令。

    资料称:这样的指令才有Read-Modify-Write功效
    ANL (logical AND, e.G., ANL P1,A)
    ORL (logical OR, e.g., ORL P2,A)
    XRL (logical EX-OR, e.g., XRL P3,A)
    JBC (jump if bit = 1 and clear bit, e.g., JBC P1.1, LABEL)
    CPL (complement bit, e.g., CPL P3.0)
    INC (increment, e.g., INC P2)
    DEC (decrement, e.g., DEC P2)
    DJNZ (decrement and jump if not zero, e.g., DJNZ P3, LABEL)
    MOV PX.Y,C(move carry bit to bit Y of
     PORT X)
    CLR PX.Y(clear bit Y of
     PORT X)
    SETB PX.Y(set bit Y of
     PORT X)

    引脚的指令:如下所示,读之前应先将端口置1,即先输出1,修改锁存器的内容为1

    MOV A, P1
    MOV 20H, P1
    MOV R0, P1
    MOV @R0, P1

    2、为什么读之前要先写1

    从上图可知,如果不对端口置1,端口锁存器原来的状态有可能为0,Q端为0,Q^为1,加到场效应管栅极的信号为1,该场效应管就导通对地呈现低阻抗,此时即使引脚上输入的信号为1也会因端口的低阻抗而使信号拉低,使得外加的1信号读入后不一定是1,若先执行置1操作则可以使场效应管截止,引脚信号直接加到三态缓冲器中,实现正确的读入。

    3、实际应用

    P0、P1、P2、P3作I/0口使用时,如果要从外部读取数据,读取之前应先将端口置1。因初始化时,四个I/O均被初始化为0XFF,所以若端口在整个程序过程中无输出时,即输出锁存器的状态始终为1,则读数据时可不用手动置1。(附:参考引脚内部结构图可知,纵使锁存器D口数据在变(内部数据线),只要时钟触发端clk没有触发信号,锁存器中的内容永远都不会改变,也就是说,不管外部引脚信号如何变,也不管执行过多少次读引脚操作,端口锁存器中的内容是不会发生变化的。那么,端口内容何时变化?答曰:只要执行过一次输出,端口内容必为输出值,因为端口就是输出的数据锁存器。)

    而当端口实际应用时要不停地同外部数据交换时,即又有输出又有读入时,如单片机与存储器<?xml:namespace prefix = st1 />24C16通过I2C总线相连,SCL总是由单片机输出可不用考虑,而SDA则可通过单片机向外发数据,又可以从外部读数据,假若之前发送的最后一位数据为0时,此时若再读数据,因为锁存器的状态仍为0,则之后立即读数据时就有可能出错。所以实际操作时,在发送数据代码之后,总会有一个单片机主动将SDA拉高的指令,之后再读数据时才不会出问题。(本人浅见,不一定正确)

    而当P0P2口作总线使用与外部并口连接时,应该就不会有上面的问题,因为从上图可各,当作总线使用时,在控制信号的作用下,与门导通,同时多路开关通过反向器与“地址/数据总线”连接,此时V1V2的驱动电路形成反相,形成推拉式电路。在这种情况下输出时,可直接驱动电路,不需要接上拉电阻(因为V1导通)。而输入时,直接读引脚即可,不需置1。(因为输入时,地址/数据线上没有数据,V2应该截止(我认为的))

    ----------------------------------

    P1_0=!P1_0在KEIL中编译后的反汇编指令为CPL 1.0;从上面所述可知为读端口指令,所以可以在C中直接使用,如用作看门狗的清除脉冲和LED灯的闪烁等。

    读端口指令似乎是要对内部的端口寄存器(P0~P4)进行改写时才进行的,所有说要先读端口锁存器状态,改写完后同时有锁存器输出

    而读引脚指令没有改写寄存器

    展开全文
  • QMap多线程读写存在的问题分析

    千次阅读 2020-01-01 19:55:35
    单列集合可以多线程并行读写而无需加锁(不考虑数据同步的情况下),而双列集合,例如QMap,如果不加锁进行多线性并行读写会出现内存冲突访问的问题,不加锁的情况下只能并行读。下面本文就对QMap在多线程并行读写...
  • 并行文件系统近期的一些研究

    千次阅读 2016-08-05 14:38:34
    作者:朱赛凡 近期对并行文件系统做一些一些研究,主要...2 并行文件系统更多用在高性能计算中,这样场景一般包括:(1) 多个分析进程并行读写一个非常大文件; (2) 单个进程能够以非常大的带宽读写一个文件;
  • 访问的存储单元不同,可并行读写存储体; 有冲突读写 访问同一存储单元,可使用/BUSY信号控制读写优先顺序; 显卡上的存储器一般都是双端口存储器。 3.5.2 多模块交叉存储器 多模块交叉存储器采用时间并行技术。 ...
  • 线程编程之读写

    2016-12-28 11:51:40
    与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。的并行 读写锁状态: 一把读写锁具备三种状态:  1. 读模式下加锁状态 (读锁)  2. 写模式下加锁状态 (写锁)  3. 不加锁状态 读写锁...
  • 并行文件系统是文件系统一种,常用于高性能计算领域,能支持数据的并行读写。并行文件系统能很好的支持并行计算,支持并行计算的大规模数据读写。 并行计算或称平行计算是相对于串行计算来说的。它是一种一次可执行...
  • 经过这次惨痛的教训,使我深刻明白了一个问题,下次再设计方法的时候,一定要将读写操作分开进行,否则就会出现十分严重的问题。 虽然整个过程困难无比,但还是收获巨大的,这种感觉真的特别好。 我想以后真的不...
  • 目前整个计算机系统中,存储...多磁头多磁道并行存储系统——MHMS,可以极好地解决目前存储系统的瓶颈,读写速度可以轻松达到10GB/s以上,替代目前的硬盘系统,甚至是替代内存系统!  读写速度可达10GB/s的机械硬盘,
  • 提供像操作本地文件一样操作远程文件(访问,并行读写,拆分,排它,复制,解析,事务等)用于利用多机硬盘存储能力;由于多计算机物理上独立,Fourinone框架也提供完整的分布式协同和锁以及简化MQ功能,用于实现多机的...
  • 读写锁_读写锁_源码

    2021-10-03 00:48:32
    读写锁代码可实现对链表的加锁功能,原为并行程序设计基础书121代码实现
  • 读写分离

    2018-12-20 18:14:49
    mysql读写分离的原理读写分离的过程半同步复制并行复制读写分离出现的问题主从复制数据丢失产生原因解决方案:半同步复制主从复制延迟问题产生原因解决方案: 什么是读写分离? 读操作访问从库,写操作访问主库 针对...
  • 读写

    千次阅读 2018-04-01 21:13:53
    与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。 读写锁状态: 一把读写锁具备三种状态: 1. 读模式下加锁状态 (读锁) 2. 写模式下加锁状态 (写锁) 3. 不加锁状态 读写锁特性: ...
  • 摘要:本文通过简单的例子来解析,大数据实践中的Spark读写流程,内容主要聚焦于Spark中的高效并行读写以及在写过程中如何保证事务性。 导读: 众所周知,在大数据/数据库领域,数据的存储格式直接影响着系统的...
  • [并行计算] 1. 并行计算简介

    万次阅读 多人点赞 2017-07-20 15:30:07
    这篇帖子旨在为并行计算这一广泛而宏大的话题提供一个非常快速的概述,作为随后教程的先导。因此,它只涵盖了并行计算的基础知识,实用于刚刚开始熟悉该主题的初学者。
  • 一,HDFS出现的背景虽然硬盘存储容量在不断提升,但是访问速度(I/O)跟不上,解决办法是数据存储在多个硬盘,同时对多个硬盘的数据并行读写。 这样需要解决两个问题:一是硬件故障问题,二是分析任务需要结合不同...
  • 本书介绍目前最常见的并行程序—MPI并行程序的设计方法它适合高校三四年级本科生非计算机专业研究生作为教材和教学自学参考书也适合于广大的并行计算高...2 主要包括三个部分动态进程管理远程存储访问和并行文件读写
  • 并行IO

    2018-02-19 10:44:38
     MPI-1对文件的操作是使用绑定语言的函数调用来进行的,通常采用的是串行IO的读写方式,一般情况下是用一个主进程打开文件和读取数据,然后分发给其他进程来处理,这种串行IO数据的通信量很大、效率较低。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,278
精华内容 52,111
关键字:

并行读写