contrib/faiss/faiss/impl/io_macros.h

Source
/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

#pragma once

#include <faiss/impl/maybe_owned_vector.h>

/*************************************************************
 * I/O macros
 *
 * we use macros so that we have a line number to report in abort
 * (). This makes debugging a lot easier. The IOReader or IOWriter is
 * always called f and thus is not passed in as a macro parameter.
 **************************************************************/

#define READANDCHECK(ptr, n)                         \
    {                                                \
        size_t ret = (*f)(ptr, sizeof(*(ptr)), n);   \
        FAISS_THROW_IF_NOT_FMT(                      \
                ret == (n),                          \
                "read error in %s: %zd != %zd (%s)", \
                f->name.c_str(),                     \
                ret,                                 \
                size_t(n),                           \
                strerror(errno));                    \
    }

#define READ1(x) READANDCHECK(&(x), 1)

#define READ1_DUMMY(x_type) \
    {                       \
        x_type x = {};      \
        READ1(x);           \
    }

// will fail if we write 256G of data at once...
#define READVECTOR(vec)                                              \
    {                                                                \
        size_t size;                                                 \
        READANDCHECK(&size, 1);                                      \
        FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
        (vec).resize(size);                                          \
        READANDCHECK((vec).data(), size);                            \
    }

#define WRITEANDCHECK(ptr, n)                         \
    {                                                 \
        size_t ret = (*f)(ptr, sizeof(*(ptr)), n);    \
        FAISS_THROW_IF_NOT_FMT(                       \
                ret == (n),                           \
                "write error in %s: %zd != %zd (%s)", \
                f->name.c_str(),                      \
                ret,                                  \
                size_t(n),                            \
                strerror(errno));                     \
    }

#define WRITE1(x) WRITEANDCHECK(&(x), 1)

#define WRITEVECTOR(vec)                   \
    {                                      \
        size_t size = (vec).size();        \
        WRITEANDCHECK(&size, 1);           \
        WRITEANDCHECK((vec).data(), size); \
    }

// read/write xb vector for backwards compatibility of IndexFlat

#define WRITEXBVECTOR(vec)                         \
    {                                              \
        FAISS_THROW_IF_NOT((vec).size() % 4 == 0); \
        size_t size = (vec).size() / 4;            \
        WRITEANDCHECK(&size, 1);                   \
        WRITEANDCHECK((vec).data(), size * 4);     \
    }

#define READXBVECTOR(vec)                                            \
    {                                                                \
        size_t size;                                                 \
        READANDCHECK(&size, 1);                                      \
        FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
        size *= 4;                                                   \
        (vec).resize(size);                                          \
        READANDCHECK((vec).data(), size);                            \
    }

Line	Count	Source
1		/*
2		* Copyright (c) Meta Platforms, Inc. and affiliates.
3		*
4		* This source code is licensed under the MIT license found in the
5		* LICENSE file in the root directory of this source tree.
6		*/
7
8		#pragma once
9
10		#include <faiss/impl/maybe_owned_vector.h>
11
12		/*************************************************************
13		* I/O macros
14		*
15		* we use macros so that we have a line number to report in abort
16		* (). This makes debugging a lot easier. The IOReader or IOWriter is
17		* always called f and thus is not passed in as a macro parameter.
18		**************************************************************/
19
20		#define READANDCHECK(ptr, n) \
21	4.54k	{ \
22	4.54k	size_t ret = (f)(ptr, sizeof((ptr)), n); \
23	4.54k	FAISS_THROW_IF_NOT_FMT( \
24	4.54k	ret == (n), \
25	4.54k	"read error in %s: %zd != %zd (%s)", \
26	4.54k	f->name.c_str(), \
27	4.54k	ret, \
28	4.54k	size_t(n), \
29	4.54k	strerror(errno)); \
30	4.54k	}
31
32	2.81k	#define READ1(x) READANDCHECK(&(x), 1)
33
34		#define READ1_DUMMY(x_type) \
35	131	{ \
36	131	x_type x = {}; \
37	131	READ1(x); \
38	131	}
39
40		// will fail if we write 256G of data at once...
41		#define READVECTOR(vec) \
42	706	{ \
43	706	size_t size; \
44	706	READANDCHECK(&size, 1); \
45	706	FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
46	706	(vec).resize(size); \
47	706	READANDCHECK((vec).data(), size); \
48	706	}
49
50		#define WRITEANDCHECK(ptr, n) \
51	2.70k	{ \
52	2.70k	size_t ret = (f)(ptr, sizeof((ptr)), n); \
53	2.70k	FAISS_THROW_IF_NOT_FMT( \
54	2.70k	ret == (n), \
55	2.70k	"write error in %s: %zd != %zd (%s)", \
56	2.70k	f->name.c_str(), \
57	2.70k	ret, \
58	2.70k	size_t(n), \
59	2.70k	strerror(errno)); \
60	2.70k	}
61
62	1.68k	#define WRITE1(x) WRITEANDCHECK(&(x), 1)
63
64		#define WRITEVECTOR(vec) \
65	402	{ \
66	402	size_t size = (vec).size(); \
67	402	WRITEANDCHECK(&size, 1); \
68	402	WRITEANDCHECK((vec).data(), size); \
69	402	}
70
71		// read/write xb vector for backwards compatibility of IndexFlat
72
73		#define WRITEXBVECTOR(vec) \
74	75	{ \
75	75	FAISS_THROW_IF_NOT((vec).size() % 4 == 0); \
76	75	size_t size = (vec).size() / 4; \
77	75	WRITEANDCHECK(&size, 1); \
78	75	WRITEANDCHECK((vec).data(), size * 4); \
79	75	}
80
81		#define READXBVECTOR(vec) \
82	140	{ \
83	140	size_t size; \
84	140	READANDCHECK(&size, 1); \
85	140	FAISS_THROW_IF_NOT(size >= 0 && size < (uint64_t{1} << 40)); \
86	140	size *= 4; \
87	140	(vec).resize(size); \
88	140	READANDCHECK((vec).data(), size); \
89	140	}

Coverage Report

Created: 2026-05-28 20:43