示例#1
0
    def getitem(self, idx):
        if self.permutation is not None and idx != self.num_batches - 1:
            idx = self.permutation[idx]
        raw_label_data = os.pread(self.label_file,
                                  self.bytes_per_batch["label"],
                                  idx * self.bytes_per_batch["label"])
        click = torch.from_numpy(
            np.frombuffer(raw_label_data, dtype=np.float32))

        if self.numerical_features_file is not None:
            raw_numerical_data = os.pread(
                self.numerical_features_file,
                self.bytes_per_batch["numerical"],
                idx * self.bytes_per_batch["numerical"])
            numerical_features = torch.from_numpy(
                np.frombuffer(raw_numerical_data,
                              dtype=np.float32)).view(-1, 13)
        else:
            numerical_features = None

        if self.categorical_features_files is not None:
            categorical_features = []
            for cat_file in self.categorical_features_files:
                raw_cat_data = os.pread(
                    cat_file, self.bytes_per_batch["categorical"],
                    idx * self.bytes_per_batch["categorical"])
                categorical_features.append(
                    torch.from_numpy(
                        np.frombuffer(raw_cat_data,
                                      dtype=np.int32)).unsqueeze(1))
            categorical_features = torch.cat(categorical_features, dim=1)
        else:
            categorical_features = None

        return click, numerical_features, categorical_features
示例#2
0
文件: dataset.py 项目: rhdong/HugeCTR
    def _get(self, idx):
        # calculate the offset & number of the samples to be read
        if not self._drop_last and idx == self._num_entries - 1:
            sample_offset = idx * (self._batch_size * self._global_size) + self._last_batch_offset[self._global_rank]
            batch = self._samples_in_last_batch
        else:
            sample_offset = idx * (self._batch_size * self._global_size) + (self._batch_size * self._global_rank)
            batch = self._batch_size

        # read the data from binary file
        label_raw_data = os.pread(self._label_file, 1 * batch, 1 * sample_offset)
        label = np.frombuffer(label_raw_data, dtype=np.bool_).reshape([batch, 1])

        dense_raw_data = os.pread(self._dense_file, 26 * batch, 26 * sample_offset)
        dense = np.frombuffer(dense_raw_data, dtype=np.float16).reshape([batch, 13])

        category = []
        for i in range(26):
            category_raw_data = os.pread(self._category_file[i], self._category_bytes[i] * batch, self._category_bytes[i] * sample_offset)
            category.append(np.frombuffer(category_raw_data, dtype=self._category_type[i]).reshape([batch, 1]).astype(np.int32))
        category = np.concatenate(category, axis=1)

        # convert numpy data to tensorflow data
        label = tf.convert_to_tensor(label, dtype=tf.float32)
        dense = tf.convert_to_tensor(dense, dtype=tf.float32)
        category = tf.convert_to_tensor(category, dtype=tf.int64)

        return (dense, category), label
示例#3
0
 def readLine(self):
     data = ''
     while os.pread(self.description, 1,
                    self.offset) not in [self.NEW_LINE, self.END_OF_FILE]:
         data += str(os.pread(self.description, 1, self.offset),
                     self.encoding)
         self.offset += 1
     self.offset += 1
     return data
示例#4
0
def procmem_write(path, pid, gvar_name, symoff_table, base_addrs, write_data):
    fd = os.open("/proc/{}/mem".format(pid), os.O_RDWR)
    symoff = symoff_table[gvar_name]
    base_addr = base_addrs[path]
    print("access addr = 0x{:x}".format(base_addr + symoff))
    print("before: 0x{:x}".format(
        struct.unpack("<I", os.pread(fd, 4, base_addr + symoff))[0]))
    os.pwrite(fd, struct.pack("<I", write_data), base_addr + symoff)
    print(" after: 0x{:x}".format(
        struct.unpack("<I", os.pread(fd, 4, base_addr + symoff))[0]))
示例#5
0
    def _get(self, i):
        assert i >= 0 and i < self.length
        offset = self.buflen * i
        with self.lock.rdlock():
            buf = os.pread(self.indexfp.fileno(), self.buflen, offset)
            (o, l) = unpack('Qq', buf)
            if l < 0 or o < 0:
                return None

            data = os.pread(self.datafp.fileno(), l, o)
            assert len(data) == l
            return data
示例#6
0
文件: file_cache.py 项目: k5342/pfio
    def _get(self, i):
        if i < 0 or self.length <= i:
            raise IndexError("index {} out of range ([0, {}])".format(
                i, self.length - 1))

        offset = self.buflen * i
        with self.lock.rdlock():
            buf = os.pread(self.cachefp.fileno(), self.buflen, offset)
            (o, l) = unpack('Qq', buf)
            if l < 0 or o < 0:
                return None

            data = os.pread(self.cachefp.fileno(), l, o)
            assert len(data) == l
            return data
示例#7
0
    def read(self, n=-1):
        data = ''
        offset = 0
        if n <= -1:
            while os.pread(self.description, 1, offset):
                data += str(os.pread(self.description, 1, offset),
                            self.encoding)
                offset += 1
        else:
            while offset != n:
                data += str(os.pread(self.description, 1, offset),
                            self.encoding)
                offset += 1

        return data
示例#8
0
    def _read_chunks_from_disk(self, fds, offsets, sizes):
        sum_read_nbytes = 0  # for prometheus counter
        st = time.time()

        for i_smd in range(self.n_smd_files):
            if self.use_smds[i_smd]: continue  # smd data were already copied

            offset = offsets[i_smd]
            size = sizes[i_smd]
            chunk = bytearray()
            for _ in range(self.max_retries + 1):
                chunk.extend(os.pread(fds[i_smd], size, offset))
                got = memoryview(chunk).nbytes
                if got == sizes[i_smd]:
                    break
                offset += got
                size -= got
            self.bigdata[i_smd].extend(chunk)
            sum_read_nbytes += sizes[i_smd]
        en = time.time()
        rate = 0
        if sum_read_nbytes > 0:
            rate = (sum_read_nbytes / 1e6) / (en - st)
        logger.debug(
            f"event_manager: bd reads chunk {sum_read_nbytes/1e6:.5f} MB took {en-st:.2f} s (Rate: {rate:.2f} MB/s)"
        )
        self._inc_prometheus_counter('MB', sum_read_nbytes / 1e6)
        self._inc_prometheus_counter('seconds', en - st)
        return
示例#9
0
def hash_genesis_block():

    blockheader = (
        "02000000" +
        "a4051e368bfa0191e6c747507dd0fdb03da1a0a54ed14829810b97c6ac070000" +
        "e932b0f6b8da85ccc464d9d5066d01d904fb05ae8d1ddad7095b9148e3f08ba6" +
        "bcfb6459" + "f0ff0f1e" + "3682bb08")
    print("txdata:%s" % blockheader)
    blockheader_bin = binascii.unhexlify(swap_order(blockheader))
    tx_data = blockheader_bin

    # Open files
    fd_h2c = os.open("/dev/xdma/card0/h2c0", os.O_WRONLY)
    fd_c2h = os.open("/dev/xdma/card0/c2h0", os.O_RDONLY)

    start_time = time.time()
    # Send to FPGA
    os.pwrite(fd_h2c, tx_data, 0)

    # Receive from FPGA
    rx_data = os.pread(fd_c2h, 32, 0)
    end_time = time.time()
    delay = end_time - start_time
    blockheder_rx = codecs.encode(rx_data, 'hex').decode('ascii')
    print("rxdata:%s" % swap_order(blockheder_rx)[0:64])
    print("Time elapsed:%f microsec" % (delay * 1000000))
    os.close(fd_h2c)
    os.close(fd_c2h)
示例#10
0
def main():

    fd = os.open("/dev/xdma0_user", os.O_RDWR)

    # sysmon is at 0x3000; first register of interest (temperature) is at 0x200
    sysmon_base = 0x3200

    vals = []

    for reg in range(0x28):
        temp_string = os.pread(fd, 4, sysmon_base + (reg * 4))
        temp_int = int.from_bytes(temp_string, byteorder='little')
        vals.append(temp_int)

    # At this point, vals contains the integer values read from ADC, with the same index as the ADC register offset

    printf("           | CUR  | MIN  | MAX  |\n")
    printf("Temp C     | %.1f | %.1f | %.1f |\n", ConvTemp(vals[0]),
           ConvTemp(vals[0x24]), ConvTemp(vals[0x20]))
    printf("VCCInt     | %.2f | %.2f | %.2f |\n", ConvVolt(vals[1]),
           ConvVolt(vals[0x25]), ConvVolt(vals[0x21]))
    printf("VCCAux     | %.2f | %.2f | %.2f |\n", ConvVolt(vals[2]),
           ConvVolt(vals[0x26]), ConvVolt(vals[0x22]))

    os.close(fd)
示例#11
0
 def _read_chunks_from_disk(self, fds, offsets, sizes):
     sum_read_nbytes = 0  # for prometheus counter
     st = time.time()
     for i in range(self.n_smd_files):
         offset = offsets[i]
         size = sizes[i]
         chunk = bytearray()
         for j in range(self.max_retries + 1):
             chunk.extend(os.pread(fds[i], size, offset))
             got = memoryview(chunk).nbytes
             if got == sizes[i]:
                 break
             offset += got
             size -= got
         self.bigdata[i].extend(chunk)
         sum_read_nbytes += sizes[i]
     en = time.time()
     rate = 0
     if sum_read_nbytes > 0:
         rate = (sum_read_nbytes / 1e6) / (en - st)
     logging.info(
         f"event_manager: bd reads chunk {sum_read_nbytes/1e6:.5f} MB took {en-st:.2f} s (Rate: {rate:.2f} MB/s)"
     )
     self._inc_prometheus_counter('MB', sum_read_nbytes / 1e6)
     return
示例#12
0
            def handle_v(subcmd):

                if subcmd == 'MustReplyEmpty':
                    self.send("")

                elif subcmd.startswith('File:open'):
                    (file_path, flags, mode) = subcmd.split(':')[-1].split(',')
                    file_path = unhexlify(file_path).decode(encoding='UTF-8')
                    flags = int(flags, base=16)
                    mode = int(mode, base=16)
                    if file_path.startswith(self.rootfs_abspath):
                        file_abspath = file_path
                    else:
                        file_abspath = self.ql.os.transform_to_real_path(file_path)
                    
                    self.ql.log.debug("gdb> target file: %s" % (file_abspath))
                    if os.path.exists(file_abspath) and not (file_path).startswith("/proc"):
                        fd = os.open(file_abspath, flags, mode)
                        self.send("F%x" % fd)
                    else:
                        self.send("F-1")

                elif subcmd.startswith('File:pread:'):
                    (fd, count, offset) = subcmd.split(':')[-1].split(',')

                    fd = int(fd, base=16)
                    offset = int(offset, base=16)
                    count = int(count, base=16)

                    data = os.pread(fd, count, offset)
                    size = len(data)
                    data = self.bin_to_escstr(data)

                    if data:
                        self.send(("F%x;" % size).encode() + (data))
                    else:
                        self.send("F0;")

                elif subcmd.startswith('File:close'):
                    fd = subcmd.split(':')[-1]
                    fd = int(fd, base=16)
                    os.close(fd)
                    self.send("F0")

                elif subcmd.startswith('Kill'):
                    self.send('OK')

                elif subcmd.startswith('Cont'):
                    self.ql.log.debug("gdb> Cont command received: %s" % subcmd)
                    if subcmd == 'Cont?':
                        self.send('vCont;c;C;t;s;S;r')
                    elif subcmd.startswith ("Cont;"):
                        subcmd = subcmd.split(';')
                        subcmd = subcmd[1].split(':')
                        if subcmd[0] in ('c', 'C05'):
                            handle_c(subcmd)
                        elif subcmd[0] in ('S', 's', 'S05'):
                            handle_s(subcmd)
                else:
                    self.send("")
示例#13
0
    def _read(self, fd, size, offset):
        st = time.monotonic()
        chunk = bytearray()
        for i_retry in range(self.max_retries+1):
            chunk.extend(os.pread(fd, size, offset))
            got = memoryview(chunk).nbytes
            if got == size:
                break
            offset += got
            size -= got

            found_xtc2_flags = self.dm.found_xtc2('bd')
            if got == 0 and all(found_xtc2_flags):
                print(f'bigddata got 0 byte and .xtc2 files found on disk. stop reading this .inprogress file')
                break

            print(f'bigdata read retry#{i_retry} - waiting for {size/1e6} MB, max_retries: {self.max_retries} (PS_R_MAX_RETRIES), sleeping 1 second...') 
            time.sleep(1)
        
        en = time.monotonic()
        sum_read_nbytes = memoryview(chunk).nbytes # for prometheus counter
        rate = 0
        if sum_read_nbytes > 0:
            rate = (sum_read_nbytes/1e6)/(en-st)
        logger.debug(f"bd reads chunk {sum_read_nbytes/1e6:.5f} MB took {en-st:.2f} s (Rate: {rate:.2f} MB/s)")
        self._inc_prometheus_counter('MB', sum_read_nbytes/1e6)
        self._inc_prometheus_counter('seconds', en-st)
        return chunk
示例#14
0
 def update(self):
     try:
         self.sync_led_state ^= True
         keypress = os.pread(self.fd, 1, 0xDB)[0]
         if (keypress & 0b01000000):
             log.info('Fn+F11 keypress')
             new = dict(iter_state())
             airplane_mode = any(new.values())
             sync_led(self.fd, airplane_mode)
             if airplane_mode:
                 self.restore = new
                 self.old = dict(iter_write_airplane_on())
             else:
                 self.old = dict(iter_write_airplane_off(self.restore))
             write_int(self.fd, 0xDB, clear_bit6(keypress))
             log.info('airplane_mode: %r', airplane_mode)
         elif self.sync_led_state:
             new = dict(iter_state())
             if new != self.old:
                 log.info('%r != %r', new, self.old)
                 self.old = new
                 airplane_mode = not any(new.values())
                 sync_led(self.fd, airplane_mode)
                 log.info('airplane_mode: %r', airplane_mode)
         return True
     except Exception:
         log.exception('Error in AirplaneMode.update():')
         return False
    def _get(self, i):
        assert 0 <= i < self.length

        self._open_fds()
        offset = self.buflen * i
        fcntl.flock(self.index_fd, fcntl.LOCK_SH)
        index_entry = os.pread(self.index_fd, self.buflen, offset)
        (o, l) = unpack('Qq', index_entry)
        if l < 0 or o < 0:
            fcntl.flock(self.index_fd, fcntl.LOCK_UN)
            return None

        data = os.pread(self.data_fd, l, o)
        assert len(data) == l
        fcntl.flock(self.index_fd, fcntl.LOCK_UN)
        return data
示例#16
0
    def empty_bin(self, worker_no):
        data_bin = self.workers_bins[worker_no]
        offset = 0
        os.lseek(data_bin["file"], offset, 0)

        all_observations = np.zeros(
            shape=[data_bin["size"], *self.input_metadata[0][1:]],
            dtype=self.input_metadata[1])
        all_actions = np.zeros(
            shape=[data_bin["size"], *self.action_metadata[0][1:]],
            dtype=self.action_metadata[1])
        all_rewards = np.zeros(shape=[data_bin["size"]],
                               dtype=self.reward_metadata[1])

        for i in range(data_bin["size"]):
            data_bytes = os.pread(data_bin["file"], self.line_bytes, offset)
            observation, action, reward = self.parse_data(data_bytes)
            all_observations[i] = observation
            all_actions[i] = action
            all_rewards[i] = reward

            offset += self.line_bytes

        data_bin["size"] = 0
        os.ftruncate(data_bin["file"], 0)
        return all_observations, all_actions, all_rewards
示例#17
0
    def _put(self, i, data):
        if self.closed:
            return False
        if i < 0 or self.length <= i:
            raise IndexError("index {} out of range ([0, {}])".format(
                i, self.length - 1))

        self._open_fds()

        index_ofst = self.buflen * i
        fcntl.flock(self.cache_fd, fcntl.LOCK_EX)
        buf = os.pread(self.cache_fd, self.buflen, index_ofst)
        (o, l) = unpack('Qq', buf)

        if l >= 0 and o >= 0:
            # Already data exists
            fcntl.flock(self.cache_fd, fcntl.LOCK_UN)
            return False

        data_pos = os.lseek(self.cache_fd, 0, os.SEEK_END)
        if self.cache_size_limit:
            if self.cache_size_limit < (data_pos + len(data)):
                self._frozen = True
                fcntl.flock(self.cache_fd, fcntl.LOCK_UN)
                return False

        index_entry = pack('Qq', data_pos, len(data))
        assert os.pwrite(self.cache_fd, index_entry, index_ofst) == self.buflen
        assert os.pwrite(self.cache_fd, data, data_pos) == len(data)
        os.fsync(self.cache_fd)
        fcntl.flock(self.cache_fd, fcntl.LOCK_UN)
        return True
示例#18
0
 def read(self, phys_addr, len):
     res = gdb.execute(f"monitor gpa2hva {hex(phys_addr)}", to_string=True)
     try:
         hva = int(res.split(" ")[-1], 16)
     except:
         raise OSError("Physical address is not accessible")
     return os.pread(self.file, len, hva)
示例#19
0
def procmem_read(path, pid, gvar_name, symoff_table, base_addrs):
    fd = os.open("/proc/{}/mem".format(pid), os.O_RDWR)
    symoff = symoff_table[gvar_name]
    base_addr = base_addrs[path]
    print("access addr = 0x{:x}".format(base_addr + symoff))
    print("read result: 0x{:x}".format(
        struct.unpack("<I", os.pread(fd, 4, base_addr + symoff))[0]))
示例#20
0
    def empty_attack_bin(self, worker_no):
        data_bin = self.workers_bins[worker_no]["attack"]
        offset = 0
        os.lseek(data_bin["file"], offset, 0)

        all_observations = np.zeros(
            shape=[data_bin["size"], *self.input_metadata[0][1:]],
            dtype=self.input_metadata[1])
        all_attack_actions = np.zeros(
            shape=[data_bin["size"], *self.attack_metadata[0][1:]],
            dtype=self.attack_metadata[1])
        #all_rewards = np.zeros(shape=[data_bin["size"]], dtype=self.reward_metadata[1])
        all_modes = np.zeros(
            shape=[data_bin["size"], *self.mode_metadata[0][1:]],
            dtype=self.mode_metadata[1])

        line_bytes = self.input_bytes + self.attack_bytes

        for i in range(data_bin["size"]):
            data_bytes = os.pread(data_bin["file"], line_bytes, offset)
            observation, attack_action = self.parse_attack_data(data_bytes)
            all_observations[i] = observation
            all_attack_actions[i] = attack_action
            #all_rewards[i] = reward
            all_modes[i][1] = 1

            offset += line_bytes

        data_bin["size"] = 0
        os.ftruncate(data_bin["file"], 0)
        return all_observations, all_attack_actions, all_modes
示例#21
0
    def _get_numerical_features(self, idx: int) -> Optional[torch.Tensor]:
        if self._numerical_features_file is None:
            return None

        raw_numerical_data = os.pread(self._numerical_features_file, self._numerical_bytes_per_batch,
                                      idx * self._numerical_bytes_per_batch)
        array = np.frombuffer(raw_numerical_data, dtype=np.float16)
        return torch.from_numpy(array).view(-1, self._number_of_numerical_features)
示例#22
0
 def _get_label(self, idx: int) -> tf.Tensor:
     raw_label_data = os.pread(self._label_file,
                               self._label_bytes_per_batch,
                               idx * self._label_bytes_per_batch)
     array = np.frombuffer(raw_label_data, dtype=np.bool)
     array = tf.convert_to_tensor(array, dtype=tf.float32)
     array = tf.expand_dims(array, 1)
     return array
示例#23
0
 def read(self, address, length, chunk_size, overlap=0):
     while length:
         readback = min(chunk_size, length)
         yield address, os.pread(self._procmem, readback, address)
         if readback > overlap:
             readback -= overlap
         address += readback
         length -= readback
示例#24
0
def read64(address):
    if address % 16 == 0:
        read64.rdata = int.from_bytes(
            os.pread(fd_c2h, 16, address + 0x20000000), 'little')

    data = read64.rdata % (2**64)
    read64.rdata = read64.rdata // (2**64)
    return data
示例#25
0
def mem_test_random():
    # Status
    test_ok = True
    test_msg = "OK\n"

    # This is the only number that should need to change- how many MB to generate
    # 256M16 part is 512MB; 512M16 part is 1024GB
    NUM_MB = 1024

    # Generate some data
    TRANSFER_SIZE = 1024 * 1024 * 4
    NUM_TRANSFERS = int(NUM_MB / 4)
    tx_data = []
    rx_data = []
    for page in range(NUM_TRANSFERS):
        tx_data.append(bytearray(numpy.random.bytes(TRANSFER_SIZE)))

    # Open files
    fd_h2c = os.open("/dev/xdma0_h2c_0", os.O_WRONLY)
    fd_c2h = os.open("/dev/xdma0_c2h_0", os.O_RDONLY)

    # Send to FPGA block RAM
    start = time.time()
    for page in range(NUM_TRANSFERS):
        os.pwrite(fd_h2c, tx_data[page], page * TRANSFER_SIZE)
    end = time.time()
    duration = end - start

    # Print time
    BPS = TRANSFER_SIZE * NUM_TRANSFERS / (duration)
    print("Sent in " + str((duration) * 1000.0) + " milliseconds (" +
          str(BPS / 1000000) + " MBPS)")

    # Receive from FPGA block RAM
    start = time.time()
    for page in range(NUM_TRANSFERS):
        rx_data.append(os.pread(fd_c2h, TRANSFER_SIZE, page * TRANSFER_SIZE))
    end = time.time()
    duration = end - start

    # Print time
    BPS = TRANSFER_SIZE * NUM_TRANSFERS / (duration)
    print("Received in " + str((duration) * 1000.0) + " milliseconds (" +
          str(BPS / 1000000) + " MBPS)")

    # Make sure data matches
    for page in range(NUM_TRANSFERS):
        if tx_data[page] != rx_data[page]:
            test_ok = False
            test_msg = "Whoops on page " + str(page) + "\n"
            print(test_msg)

    with open('err.log', 'a') as errlog:
        errlog.write(test_msg)

    os.close(fd_h2c)
    os.close(fd_c2h)
示例#26
0
def read_proc_output(logfd, offset):
    size = os.fstat(logfd).st_size
    if size > offset:
        data = os.pread(logfd, size - offset, offset)
        sys.stdout.write(data.decode('utf-8'))
        offset = size
    else:
        data = None
    return offset, data
示例#27
0
def main():

    fd = os.open("/dev/xdma0_user", os.O_RDONLY)

    temp_string = os.pread(fd, 4, 0x1000)

    print("Version " + str(temp_string))

    os.close(fd)
示例#28
0
    def _get(self, i):
        if i < 0 or self.length <= i:
            raise IndexError("index {} out of range ([0, {}])".format(
                i, self.length - 1))

        self._open_fds()
        offset = self.buflen * i
        fcntl.flock(self.cache_fd, fcntl.LOCK_SH)
        index_entry = os.pread(self.cache_fd, self.buflen, offset)
        (o, l) = unpack('Qq', index_entry)
        if l < 0 or o < 0:
            fcntl.flock(self.cache_fd, fcntl.LOCK_UN)
            return None

        data = os.pread(self.cache_fd, l, o)
        assert len(data) == l
        fcntl.flock(self.cache_fd, fcntl.LOCK_UN)
        return data
示例#29
0
def validate_erased(target, signature_map):
    target_fd = os.open(target, os.O_RDONLY)
    try:
        for sig, offset in signature_map:
            if os.pread(target_fd, 16, offset) == sig:
                return False
    finally:
        os.close(target_fd)
    return True
示例#30
0
 def read(self, length, offset):
     if self.iolock:
         self.iolock.acquire()
         try:
             self.file.seek(offset)
             return self.file.read(length)
         finally:
             self.iolock.release()
     else:
         return os.pread(self.fd, length, offset)
示例#31
0
 def __read(self, length, offset):
     '''
     Wrapper around `os.pread` to reads as much as
     requested, from the opened file.
     
     @param   length:int  The number of bytes to read.
     @param   offset:int  Whence shall we read?
     @return  :bytes      The requested area of the file.
     '''
     rc = []
     while True:
         got = os.pread(self.fd, length, offset)
         if len(got) == 0:
             break
         rc += got
         length -= len(got)
         offset += len(got)
     return rc
示例#32
0
文件: dma-test.py 项目: eiselekd/hw
def main():

    # Generate some data
    TRANSFER_SIZE = 4096
    tx_data = bytearray(os.urandom(TRANSFER_SIZE))

    # Open files
    fd_h2c = os.open("/dev/xdma/card0/h2c0", os.O_WRONLY)
    fd_c2h = os.open("/dev/xdma/card0/c2h0", os.O_RDONLY)

    # Send to FPGA block RAM
    start = time.time()
    os.pwrite(fd_h2c, tx_data, 0);
    end = time.time()
    duration = end-start;

    # Print time
    BPS = TRANSFER_SIZE / (duration);
    print("Sent in " + str((duration)*1000.0) + " milliseconds (" + str(BPS/1000000) + " MBPS)")

    # Receive from FPGA block RAM
    start = time.time()
    rx_data = os.pread(fd_c2h, TRANSFER_SIZE, 0);
    end = time.time()
    duration = end-start;

    # Print time
    BPS = TRANSFER_SIZE / (duration);
    print("Received in " + str((duration)*1000.0) + " milliseconds (" + str(BPS/1000000) + " MBPS)")

    # Make sure data matches
    if tx_data != rx_data:
        print ("Whoops")
    else:
        print ("OK")

    # done
    os.close(fd_h2c)
    os.close(fd_c2h)
示例#33
0
 def task(i):
     start = time.perf_counter()
     os.pread(disk.fileno(), bufsize, offsets[i])
     finish = time.perf_counter()
     times[i] = (finish-start)
示例#34
0
文件: file.py 项目: m-lab/mlab-ns
 def _read(self, buffersize, offset):
     """read that uses pread"""
     # pylint: disable=no-member
     return os.pread(self._handle.fileno(), buffersize, offset)
示例#35
0
print('Measuring: Concurrent random seek time using readahead.')
print('Samples: {0}   Sample size: {1}'.format(
    bufcount, bufsize))

for area in [BytesInt('1MB')*2**i for i in range(0,64)]+[disksize]:
    if area > disksize:
        continue

    os.system('echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null')

    offsets = [random.randint(0, area-bufsize) for i in range(bufcount)]

    for i in offsets:
        readahead(disk.fileno(), i, bufsize)

    times = [timeit.timeit(lambda: os.pread(disk.fileno(), bufsize, i), number=1) for i in offsets]

    print('Area tested: {0:6}   Average: {1:5.2f} ms   Max: {2:5.2f} ms   Total: {3:0.2f} sec'.format(
        BytesString(area) if area < disksize else BytesStringFloat(area), 
        sum(times)/len(times)*1000, max(times)*1000, sum(times)))


#--------------------------------------------------------------------------------------------------

bufsize = 512
bufcount = 100

print()
print('Measuring: Random seek time using beginning of disk.')
print('Samples: {0}   Sample size: {1}'.format(
    bufcount, bufsize))
示例#36
0
    os.system('echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null')

    offsets = []
    for _ in range(bufcount):
        right = random.randint(0, area)
        offsets.append(right)

    for i in offsets:
        readahead(disk.fileno(), i, bufsize)

    times = []
    disk.seek(0)
    disk.read(bufsize)
    for i in offsets:
        start = time.perf_counter()
        os.pread(disk.fileno(), bufsize, i)
        finish = time.perf_counter()
        times.append(finish-start)

    print('Area tested: {0:6}   Average: {1:5.2f} ms   Max: {2:5.2f} ms   Total: {3:0.2f} sec'.format(
        BytesString(area) if area < disksize else BytesStringFloat(area), 
        sum(times)/len(times)*1000, max(times)*1000, sum(times)))


#--------------------------------------------------------------------------------------------------

bufsize = 512
bufcount = 100

print()
print('Measuring: Concurrent random seek time using thread pool.')
示例#37
0
 def _readoff(self, off, size):
     return os.pread(self.fileno, size, off)
示例#38
0
import sys
import time
import os
from collections import namedtuple
import ctypes

class HFSplus:
    def __init__(self):
        self = self
        HFSPlusVolumeHeader = namedtuple(
                                                                                            "HFSPlusVolumeHeader", "field1 field2 field3")
        
    def volume_reader(self)
        # os.pread(fd, buffersize, offset)
        os.pread(fd, vheader, 1024)
        
        
        
#/* HFS Plus Volume Header - 512 bytes */
#/* Stored at sector #2 (3rd sector) and second-to-last sector. */
#struct HFSPlusVolumeHeader {
#   ctypes.u_int16_t    signature;      /* == kHFSPlusSigWord */
#   ctypes.u_int16_t    version;        /* == kHFSPlusVersion */
#   ctypes.u_int32_t    attributes;     /* volume attributes */
#   ctypes.u_int32_t    lastMountedVersion; /* implementation version which last mounted volume */
#   ctypes.u_int32_t    journalInfoBlock;   /* block addr of journal info (if volume is journaled, zero otherwise) */
#
#   ctypes.u_int32_t    createDate;     /* date and time of volume creation */
#   ctypes.u_int32_t    modifyDate;     /* date and time of last modification */
#   ctypes.u_int32_t    backupDate;     /* date and time of last backup */