| /external/valgrind/none/tests/mips32/ |
| block_size.vgtest | 1 prog: block_size
|
| /external/valgrind/none/tests/ppc32/ |
| data-cache-instructions.c | 21 int block_size, test_block_size = 4 * MAX_DCBZL_SZB, err; local
34 for (block_size = 0, p = rb; (p - rb) < test_block_size; p++)
36 block_size++;
37 assert(block_size == 16 || block_size == 32 || block_size == 64 || block_size == 128);
40 return block_size;
44 static void test_dcbzl_at(char *addr, char *buffer, int block_size)
48 /* Note: Assumption is that the length of buffer is three times the block_size. *
64 int block_size; local
[all...] |
| data-cache-instructions.stdout.exp | 2 Passed dcbzl test at un-aligned (1 modulo block_size) address within the test block.
3 Passed dcbzl test at un-aligned ((block_size - 1) modulo block_size) address within the test block.
|
| /external/valgrind/none/tests/ppc64/ |
| data-cache-instructions.stdout.exp | 2 Passed dcbzl test at un-aligned (1 modulo block_size) address within the test block.
3 Passed dcbzl test at un-aligned ((block_size - 1) modulo block_size) address within the test block.
|
| /external/autotest/client/site_tests/platform_DMVerityCorruption/ |
| platform_DMVerityCorruption.py | 13 def mod_zerofill_block(self, run_count, backing_path, block_size,
16 run_count, backing_path, block_size, block_count))
19 verity_utils.system(dd_cmd % (backing_path, block_size, run_count))
21 def mod_Afill_hash_block(self, run_count, backing_path, block_size,
24 run_count, backing_path, block_size, block_count))
26 dev.seek(block_count * block_size, os.SEEK_SET)
27 dev.seek(run_count * block_size, os.SEEK_CUR)
28 dev.write('A' * block_size)
40 verity_utils.BLOCK_SIZE)
|
| /external/compiler-rt/test/BlocksRuntime/ |
| hasdescriptor.c | 21 //printf("size of inner is %ld\n", Block_size(inner));
22 //printf("size of outer is %ld\n", Block_size(outer));
23 if (Block_size(inner) != Block_size(outer)) {
|
| structmember.c | 31 unsigned nominalsize = Block_size(b) - Block_size(a);
36 if ((Block_size(b) - Block_size(a)) != nominalsize) {
37 printf("sizeof a is %ld, sizeof b is %ld, expected %d\n", Block_size(a), Block_size(b), nominalsize);
|
| /external/libvpx/libvpx/vp9/encoder/ |
| vp9_encodemb.h | 30 void vp9_encode_sb(MACROBLOCK *x, BLOCK_SIZE bsize);
31 void vp9_encode_sby_pass1(MACROBLOCK *x, BLOCK_SIZE bsize);
33 BLOCK_SIZE plane_bsize, TX_SIZE tx_size);
35 BLOCK_SIZE plane_bsize, TX_SIZE tx_size);
37 BLOCK_SIZE plane_bsize, TX_SIZE tx_size);
39 void vp9_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
42 BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg);
44 void vp9_encode_intra_block_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane,
|
| vp9_pickmode.h | 21 BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx);
25 BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx);
28 int mi_col, RD_COST *rd_cost, BLOCK_SIZE bsize,
|
| vp9_rdopt.h | 29 struct RD_COST *rd_cost, BLOCK_SIZE bsize,
35 struct RD_COST *rd_cost, BLOCK_SIZE bsize,
40 struct RD_COST *rd_cost, BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
51 struct RD_COST *rd_cost, BLOCK_SIZE bsize,
|
| /external/autotest/client/site_tests/platform_DMVerityBitCorruption/ |
| platform_DMVerityBitCorruption.py | 17 def mod_tweak_block(self, run_count, backing_path, block_size,
20 run_count, backing_path, block_size, block_count))
23 dev.seek(run_count * block_size + self._adjustment)
25 dev.seek(run_count * block_size + self._adjustment)
29 def mod_tweak_hash_block(self, run_count, backing_path, block_size,
32 run_count, backing_path, block_size, block_count))
35 dev.seek(block_count * block_size, os.SEEK_SET)
36 dev.seek(run_count * block_size + self._adjustment, os.SEEK_CUR)
39 dev.seek(block_count * block_size, os.SEEK_SET)
40 dev.seek(run_count * block_size + self._adjustment, os.SEEK_CUR
[all...] |
| /external/autotest/client/site_tests/platform_CrosDisksFilesystem/ |
| exfat_tests | 4 "block_size": 1024,
14 "block_size": 1024,
24 "block_size": 1024,
|
| ext2_tests | 4 "block_size": 1024,
14 "block_size": 1024,
25 "block_size": 1024,
|
| ext3_tests | 4 "block_size": 1024,
14 "block_size": 1024,
25 "block_size": 1024,
|
| ext4_tests | 4 "block_size": 1024,
14 "block_size": 1024,
25 "block_size": 1024,
|
| ntfs_tests | 4 "block_size": 1024,
15 "block_size": 1024,
27 "block_size": 1024,
|
| vfat_tests | 4 "block_size": 1024,
14 "block_size": 1024,
25 "block_size": 1024,
|
| /external/ltp/testcases/kernel/syscalls/fallocate/ |
| fallocate04.c | 42 static size_t block_size; variable
70 block_size = file_stat.st_blksize;
71 buf_size = NUM_OF_BLOCKS * block_size;
89 memset(buf + i * block_size, 'a' + i, block_size);
151 block_size, block_size) == -1) {
162 if (ret != (ssize_t)block_size) {
183 if ((alloc_size0 - block_size) != alloc_size1)
189 memset(exp_buf + block_size, 0, block_size)
[all...] |
| /system/extras/verity/ |
| build_verity_tree.cpp | 26 uint64_t block_size; member in struct:sparse_hash_ctx
40 size_t verity_tree_blocks(uint64_t data_size, size_t block_size, size_t hash_size,
43 size_t level_blocks = div_round_up(data_size, block_size);
44 int hashes_per_block = div_round_up(block_size, hash_size);
80 size_t block_size)
84 for (size_t i = 0; i < in_size; i += block_size) {
85 hash_block(md, in + i, block_size, salt, salt_size, out, &s);
96 assert(len % ctx->block_size == 0);
101 ctx->salt, ctx->salt_size, ctx->block_size);
104 for (size_t i = 0; i < (size_t)len; i += ctx->block_size) {
132 size_t block_size = 4096; local
[all...] |
| /external/e2fsprogs/lib/ext2fs/ |
| sparse_io.c | 39 int block_size; member in struct:sparse_map
50 unsigned int block_size; member in struct:sparse_io_params
72 if (!nr_blocks || len % sm->block_size)
99 sm->block_size = sparse_file_block_size(sparse_file);
101 / sm->block_size + 1;
107 io->block_size = sm->block_size;
136 if (!params->block_size || !params->blocks_count) {
140 sm->block_size = params->block_size;
264 unsigned int block_size = sm->block_size; local
[all...] |
| /external/squashfs-tools/squashfs-tools/ |
| compressor.h | 47 int block_size, int datablock)
51 return comp->init(stream, block_size, datablock);
56 void *dest, void *src, int size, int block_size, int *error)
58 return comp->compress(strm, dest, src, size, block_size, error);
63 void *src, int size, int block_size, int *error)
65 return comp->uncompress(dest, src, size, block_size, error);
83 static inline int compressor_options_post(struct compressor *comp, int block_size)
87 return comp->options_post(block_size);
92 int block_size, int *size)
96 return comp->dump_options(block_size, size)
[all...] |
| /external/libvpx/libvpx/vp9/encoder/arm/neon/ |
| vp9_error_neon.c | 17 int block_size) {
20 assert(block_size >= 8);
21 assert((block_size % 8) == 0);
37 block_size -= 8;
38 } while (block_size != 0);
|
| /external/opencv/cxcore/src/ |
| cxmean.cpp | 133 #define ICV_MEAN_ENTRY_BLOCK_COMMON( block_size ) \
134 int remaining = block_size; \
137 #define ICV_MEAN_ENTRY_BLOCK_C1( sumtype, worktype, block_size )\
140 ICV_MEAN_ENTRY_BLOCK_COMMON( block_size )
142 #define ICV_MEAN_ENTRY_BLOCK_C2( sumtype, worktype, block_size )\
145 ICV_MEAN_ENTRY_BLOCK_COMMON( block_size )
147 #define ICV_MEAN_ENTRY_BLOCK_C3( sumtype, worktype, block_size )\
150 ICV_MEAN_ENTRY_BLOCK_COMMON( block_size )
152 #define ICV_MEAN_ENTRY_BLOCK_C4( sumtype, worktype, block_size )\
155 ICV_MEAN_ENTRY_BLOCK_COMMON( block_size )
[all...] |
| /external/apache-commons-math/src/main/java/org/apache/commons/math/linear/ |
| BlockRealMatrix.java | 46 * The regular blocks represent {@link #BLOCK_SIZE} x {@link #BLOCK_SIZE} squares. Blocks
49 * {@link #BLOCK_SIZE}<sup>2</sup> elements long for regular blocks. The blocks are themselves
70 public static final int BLOCK_SIZE = 52;
106 blockRows = (rows + BLOCK_SIZE - 1) / BLOCK_SIZE;
107 blockColumns = (columns + BLOCK_SIZE - 1) / BLOCK_SIZE;
156 blockRows = (rows + BLOCK_SIZE - 1) / BLOCK_SIZE;
[all...] |
| BlockFieldMatrix.java | 45 * The regular blocks represent {@link #BLOCK_SIZE} x {@link #BLOCK_SIZE} squares. Blocks
48 * {@link #BLOCK_SIZE}<sup>2</sup> elements long for regular blocks. The blocks are themselves
72 public static final int BLOCK_SIZE = 36;
109 blockRows = (rows + BLOCK_SIZE - 1) / BLOCK_SIZE;
110 blockColumns = (columns + BLOCK_SIZE - 1) / BLOCK_SIZE;
159 blockRows = (rows + BLOCK_SIZE - 1) / BLOCK_SIZE;
[all...] |
