2 * Copyright 2013, GitHub, Inc
3 * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
4 * David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 #include "git-compat-util.h"
23 int ewah_serialize_native(struct ewah_bitmap
*self
, int fd
)
26 size_t to_write
= self
->buffer_size
* 8;
28 /* 32 bit -- bit size for the map */
29 write32
= (uint32_t)self
->bit_size
;
30 if (write(fd
, &write32
, 4) != 4)
33 /** 32 bit -- number of compressed 64-bit words */
34 write32
= (uint32_t)self
->buffer_size
;
35 if (write(fd
, &write32
, 4) != 4)
38 if (write(fd
, self
->buffer
, to_write
) != to_write
)
41 /** 32 bit -- position for the RLW */
42 write32
= self
->rlw
- self
->buffer
;
43 if (write(fd
, &write32
, 4) != 4)
46 return (3 * 4) + to_write
;
49 int ewah_serialize_to(struct ewah_bitmap
*self
,
50 int (*write_fun
)(void *, const void *, size_t),
55 const size_t words_per_dump
= sizeof(dump
) / sizeof(eword_t
);
56 uint32_t bitsize
, word_count
, rlw_pos
;
58 const eword_t
*buffer
;
61 /* 32 bit -- bit size for the map */
62 bitsize
= htonl((uint32_t)self
->bit_size
);
63 if (write_fun(data
, &bitsize
, 4) != 4)
66 /** 32 bit -- number of compressed 64-bit words */
67 word_count
= htonl((uint32_t)self
->buffer_size
);
68 if (write_fun(data
, &word_count
, 4) != 4)
71 /** 64 bit x N -- compressed words */
72 buffer
= self
->buffer
;
73 words_left
= self
->buffer_size
;
75 while (words_left
>= words_per_dump
) {
76 for (i
= 0; i
< words_per_dump
; ++i
, ++buffer
)
77 dump
[i
] = htonll(*buffer
);
79 if (write_fun(data
, dump
, sizeof(dump
)) != sizeof(dump
))
82 words_left
-= words_per_dump
;
86 for (i
= 0; i
< words_left
; ++i
, ++buffer
)
87 dump
[i
] = htonll(*buffer
);
89 if (write_fun(data
, dump
, words_left
* 8) != words_left
* 8)
93 /** 32 bit -- position for the RLW */
94 rlw_pos
= (uint8_t*)self
->rlw
- (uint8_t *)self
->buffer
;
95 rlw_pos
= htonl(rlw_pos
/ sizeof(eword_t
));
97 if (write_fun(data
, &rlw_pos
, 4) != 4)
100 return (3 * 4) + (self
->buffer_size
* 8);
103 static int write_helper(void *fd
, const void *buf
, size_t len
)
105 return write((intptr_t)fd
, buf
, len
);
108 int ewah_serialize(struct ewah_bitmap
*self
, int fd
)
110 return ewah_serialize_to(self
, write_helper
, (void *)(intptr_t)fd
);
113 int ewah_read_mmap(struct ewah_bitmap
*self
, void *map
, size_t len
)
115 uint32_t *read32
= map
;
119 self
->bit_size
= ntohl(*read32
++);
120 self
->buffer_size
= self
->alloc_size
= ntohl(*read32
++);
121 self
->buffer
= ewah_realloc(self
->buffer
,
122 self
->alloc_size
* sizeof(eword_t
));
127 for (i
= 0, read64
= (void *)read32
; i
< self
->buffer_size
; ++i
)
128 self
->buffer
[i
] = ntohll(*read64
++);
130 read32
= (void *)read64
;
131 self
->rlw
= self
->buffer
+ ntohl(*read32
++);
133 return (3 * 4) + (self
->buffer_size
* 8);
136 int ewah_deserialize(struct ewah_bitmap
*self
, int fd
)
140 const size_t words_per_dump
= sizeof(dump
) / sizeof(eword_t
);
141 uint32_t bitsize
, word_count
, rlw_pos
;
143 eword_t
*buffer
= NULL
;
148 /* 32 bit -- bit size for the map */
149 if (read(fd
, &bitsize
, 4) != 4)
152 self
->bit_size
= (size_t)ntohl(bitsize
);
154 /** 32 bit -- number of compressed 64-bit words */
155 if (read(fd
, &word_count
, 4) != 4)
158 self
->buffer_size
= self
->alloc_size
= (size_t)ntohl(word_count
);
159 self
->buffer
= ewah_realloc(self
->buffer
,
160 self
->alloc_size
* sizeof(eword_t
));
165 /** 64 bit x N -- compressed words */
166 buffer
= self
->buffer
;
167 words_left
= self
->buffer_size
;
169 while (words_left
>= words_per_dump
) {
170 if (read(fd
, dump
, sizeof(dump
)) != sizeof(dump
))
173 for (i
= 0; i
< words_per_dump
; ++i
, ++buffer
)
174 *buffer
= ntohll(dump
[i
]);
176 words_left
-= words_per_dump
;
180 if (read(fd
, dump
, words_left
* 8) != words_left
* 8)
183 for (i
= 0; i
< words_left
; ++i
, ++buffer
)
184 *buffer
= ntohll(dump
[i
]);
187 /** 32 bit -- position for the RLW */
188 if (read(fd
, &rlw_pos
, 4) != 4)
191 self
->rlw
= self
->buffer
+ ntohl(rlw_pos
);