Just refortmatting and added one type

author: Sebastiano Tronto <sebastiano.tronto@gmail.com> 2021-12-08 21:50:35 +0100
committer: Sebastiano Tronto <sebastiano.tronto@gmail.com> 2021-12-08 21:50:35 +0100
commit: 849edbb69700a9f7520e159d94333ef5b798685b (patch)
tree: 8239946c5962c397ab76b6757c61c284a8abca52 /src/cubetypes.h
parent: 1573b0d3077aade290f03482b1620b2295d2c58c (diff)
download: nissy-849edbb69700a9f7520e159d94333ef5b798685b.tar.gz
nissy-849edbb69700a9f7520e159d94333ef5b798685b.zip
1 files changed, 162 insertions, 149 deletions
diff --git a/src/cubetypes.h b/src/cubetypes.h
index f4e682d..ccc2d34 100644
--- a/src/cubetypes.h
+++ b/src/cubetypes.h
@@ -72,24 +72,25 @@ trans
 /* Typedefs ******************************************************************/
-typedef struct alg           Alg;
+typedef struct alg                Alg;
-typedef struct alglist       AlgList;
+typedef struct alglist            AlgList;
-typedef struct alglistnode   AlgListNode;
+typedef struct alglistnode        AlgListNode;
-typedef struct block         Block;
+typedef struct block              Block;
-typedef struct command       Command;
+typedef struct command            Command;
-typedef struct commandargs   CommandArgs;
+typedef struct commandargs        CommandArgs;
-typedef struct coordinate    Coordinate;
+typedef struct coordinate         Coordinate;
-typedef struct cube          Cube;
+typedef struct cube               Cube;
-typedef struct cubearray     CubeArray;
+typedef struct cubearray          CubeArray;
-typedef struct dfsdata       DfsData;
+typedef struct dfsdata            DfsData;
-typedef struct estimatedata  EstimateData;
+typedef struct estimatedata       EstimateData;
-typedef struct localinfo     LocalInfo;
+typedef struct localinfo          LocalInfo;
-typedef struct piecefilter   PieceFilter;
+typedef struct piecefilter        PieceFilter;
-typedef struct prunedata     PruneData;
+typedef struct prunedata          PruneData;
-typedef struct solveoptions  SolveOptions;
+typedef struct solveoptions       SolveOptions;
-typedef struct step          Step;
+typedef struct step               Step;
-typedef struct symdata       SymData;
+typedef struct symdata            SymData;
-typedef struct threaddata    ThreadData;
+typedef struct threaddatasolve    ThreadDataSolve;
+typedef struct threaddatagenpt    ThreadDataGenpt;
 typedef Cube                 (*AntiIndexer)      (uint64_t);
 typedef bool                 (*Checker)          (Cube);
@@ -108,221 +109,233 @@ typedef int                  (*TransFinder)      (uint64_t, Trans *);
 struct
 alg
 {
-        Move *            move;
+        Move *                    move;
-        bool *            inv;
+        bool *                    inv;
-        int               len;
+        int                       len;
-        int               allocated;
+        int                       allocated;
 };
 struct
 alglist
 {
-        AlgListNode *     first;
+        AlgListNode *             first;
-        AlgListNode *     last;
+        AlgListNode *             last;
-        int               len;
+        int                       len;
 };
 struct
 alglistnode
 {
-        Alg *             alg;
+        Alg *                     alg;
-        AlgListNode *     next;
+        AlgListNode *             next;
 };
 struct
 block
 {
-        bool              edge[12];
+        bool                      edge[12];
-        bool              corner[8];
+        bool                      corner[8];
-        bool              center[6];
+        bool                      center[6];
 };
 struct
 command
 {
-        char *            name;
+        char *                    name;
-        char *            usage;
+        char *                    usage;
-        char *            description;
+        char *                    description;
-        ArgParser         parse_args;
+        ArgParser                 parse_args;
-        Exec              exec;
+        Exec                      exec;
 };
 struct
 commandargs
 {
-        bool              success;
+        bool                      success;
-        Alg *             scramble;
+        Alg *                     scramble;
-        SolveOptions *    opts;
+        SolveOptions *            opts;
-        Step *            step;
+        Step *                    step;
-        Command *         command; /* For help */
+        Command *                 command; /* For help */
 };
 struct
 coordinate
 {
-        Indexer           index;
+        Indexer                   index;
-        AntiIndexer       cube;
+        AntiIndexer               cube;
-        uint64_t          max;
+        uint64_t                  max;
-        TransFinder       trans;
+        TransFinder               trans;
 };
 struct
 cube
 {
-        int               epose;
+        int                       epose;
-        int               eposs;
+        int                       eposs;
-        int               eposm;
+        int                       eposm;
-        int               eofb;
+        int                       eofb;
-        int               eorl;
+        int                       eorl;
-        int               eoud;
+        int                       eoud;
-        int               cp;
+        int                       cp;
-        int               coud;
+        int                       coud;
-        int               cofb;
+        int                       cofb;
-        int               corl;
+        int                       corl;
-        int               cpos;
+        int                       cpos;
 };
 struct
 cubearray
 {
-        int *             ep;
+        int *                     ep;
-        int *             eofb;
+        int *                     eofb;
-        int *             eorl;
+        int *                     eorl;
-        int *             eoud;
+        int *                     eoud;
-        int *             cp;
+        int *                     cp;
-        int *             coud;
+        int *                     coud;
-        int *             corl;
+        int *                     corl;
-        int *             cofb;
+        int *                     cofb;
-        int *             cpos;
+        int *                     cpos;
 };
 struct
 dfsdata
 {
-        int               d;
+        int                       d;
-        int               m;
+        int                       m;
-        int               lb;
+        int                       lb;
-        bool              niss;
+        bool                      niss;
-        Move              last1;
+        Move                      last1;
-        Move              last2;
+        Move                      last2;
-        EstimateData *    ed;
+        EstimateData *            ed;
-        AlgList *         sols;
+        AlgList *                 sols;
-        pthread_mutex_t * sols_mutex;
+        pthread_mutex_t *         sols_mutex;
-        Alg *             current_alg;
+        Alg *                     current_alg;
-        Move *            sorted_moves;
+        Move *                    sorted_moves;
-        int *             move_position;
+        int *                     move_position;
-        uint8_t *         visited;
+        uint8_t *                 visited;
 };
 struct
 estimatedata
 {
-        Cube              cube;
+        Cube                      cube;
-        int               target;
+        int                       target;
-        Move              lastmove;
+        Move                      lastmove;
-        uint64_t          movebitmask;
+        uint64_t                  movebitmask;
-        LocalInfo *       li;
+        LocalInfo *               li;
 };
 struct
 localinfo
 {
-        int               corners;
+        int                       corners;
-        int               normal_ud;
+        int                       normal_ud;
-        int               normal_fb;
+        int                       normal_fb;
-        int               normal_rl;
+        int                       normal_rl;
-        int               inverse_ud;
+        int                       inverse_ud;
-        int               inverse_fb;
+        int                       inverse_fb;
-        int               inverse_rl;
+        int                       inverse_rl;
-        int               prev_ret;
+        int                       prev_ret;
 };
 struct
 piecefilter
 {
-        bool              epose;
+        bool                      epose;
-        bool              eposs;
+        bool                      eposs;
-        bool              eposm;
+        bool                      eposm;
-        bool              eofb;
+        bool                      eofb;
-        bool              eorl;
+        bool                      eorl;
-        bool              eoud;
+        bool                      eoud;
-        bool              cp;
+        bool                      cp;
-        bool              coud;
+        bool                      coud;
-        bool              cofb;
+        bool                      cofb;
-        bool              corl;
+        bool                      corl;
-        bool              cpos;
+        bool                      cpos;
 };
 struct
 prunedata
 {
-        char *            filename;
+        char *                    filename;
-        uint8_t *         ptable;
+        uint8_t *                 ptable;
-        bool              generated;
+        bool                      generated;
-        uint64_t          n;
+        uint64_t                  n;
-        Coordinate *      coord;
+        Coordinate *              coord;
-        Moveset           moveset;
+        Moveset                   moveset;
 };
 struct
 solveoptions
 {
-        int               min_moves;
+        int                       min_moves;
-        int               max_moves;
+        int                       max_moves;
-        int               max_solutions;
+        int                       max_solutions;
-        int               nthreads;
+        int                       nthreads;
-        bool              optimal_only;
+        bool                      optimal_only;
-        bool              can_niss;
+        bool                      can_niss;
-        bool              verbose;
+        bool                      verbose;
-        bool              all;
+        bool                      all;
-        bool              print_number;
+        bool                      print_number;
 };
 struct
 step
 {
-        char *            shortname;
+        char *                    shortname;
-        char *            name;
+        char *                    name;
-        Estimator         estimate;
+        Estimator                 estimate;
-        Checker           ready;
+        Checker                   ready;
-        char *            ready_msg;
+        char *                    ready_msg;
-        Validator         is_valid;
+        Validator                 is_valid;
-        Moveset           moveset;
+        Moveset                   moveset;
-        Trans             pre_trans;
+        Trans                     pre_trans;
-        TransDetector     detect;
+        TransDetector             detect;
-        int               ntables;
+        int                       ntables;
-        PruneData *       tables[10];
+        PruneData *               tables[10];
 };
 struct
 symdata
 {
-        char *            filename;
+        char *                    filename;
-        bool              generated;
+        bool                      generated;
-        Coordinate *      coord;
+        Coordinate *              coord;
-        Coordinate *      sym_coord;
+        Coordinate *              sym_coord;
-        int               ntrans;
+        int                       ntrans;
-        Trans *           trans;
+        Trans *                   trans;
-        uint64_t *        class;
+        uint64_t *                class;
-        Cube *            rep;
+        Cube *                    rep;
-        Trans *           transtorep;
+        Trans *                   transtorep;
 };
 struct
-threaddata
+threaddatasolve
 {
-        int               thid;
+        int                       thid;
-        Cube              cube;
+        Cube                      cube;
-        Step *            step;
+        Step *                    step;
-        int               depth;
+        int                       depth;
-        Move *            sorted_moves;
+        Move *                    sorted_moves;
-        int *             move_position;
+        int *                     move_position;
-        SolveOptions *    opts;
+        SolveOptions *            opts;
-        AlgList *         start;
+        AlgList *                 start;
-        AlgListNode **    node;
+        AlgListNode **            node;
-        AlgList *         sols;
+        AlgList *                 sols;
-        pthread_mutex_t * start_mutex;
+        pthread_mutex_t *         start_mutex;
-        pthread_mutex_t * sols_mutex;
+        pthread_mutex_t *         sols_mutex;
+};
+struct
+threaddatagenpt
+{
+        int                       thid;
+        PruneData *               pd;
+        int                       d;
+        uint64_t                  rangemin;
+        uint64_t                  rangemax;
+        int                       nchunks;
+        pthread_mutex_t **        mutex;
 };
 #endif
author	Sebastiano Tronto <sebastiano.tronto@gmail.com>	2021-12-08 21:50:35 +0100
committer	Sebastiano Tronto <sebastiano.tronto@gmail.com>	2021-12-08 21:50:35 +0100
commit	849edbb69700a9f7520e159d94333ef5b798685b (patch)
tree	8239946c5962c397ab76b6757c61c284a8abca52 /src/cubetypes.h
parent	1573b0d3077aade290f03482b1620b2295d2c58c (diff)
download	nissy-849edbb69700a9f7520e159d94333ef5b798685b.tar.gz nissy-849edbb69700a9f7520e159d94333ef5b798685b.zip

diff --git a/src/cubetypes.h b/src/cubetypes.h index f4e682d..ccc2d34 100644 --- a/src/cubetypes.h +++ b/src/cubetypes.h
@@ -72,24 +72,25 @@ trans
72		72
73	/* Typedefs ******************************************************************/	73	/* Typedefs ******************************************************************/
74		74
75	typedef struct alg Alg;	75	typedef struct alg Alg;
76	typedef struct alglist AlgList;	76	typedef struct alglist AlgList;
77	typedef struct alglistnode AlgListNode;	77	typedef struct alglistnode AlgListNode;
78	typedef struct block Block;	78	typedef struct block Block;
79	typedef struct command Command;	79	typedef struct command Command;
80	typedef struct commandargs CommandArgs;	80	typedef struct commandargs CommandArgs;
81	typedef struct coordinate Coordinate;	81	typedef struct coordinate Coordinate;
82	typedef struct cube Cube;	82	typedef struct cube Cube;
83	typedef struct cubearray CubeArray;	83	typedef struct cubearray CubeArray;
84	typedef struct dfsdata DfsData;	84	typedef struct dfsdata DfsData;
85	typedef struct estimatedata EstimateData;	85	typedef struct estimatedata EstimateData;
86	typedef struct localinfo LocalInfo;	86	typedef struct localinfo LocalInfo;
87	typedef struct piecefilter PieceFilter;	87	typedef struct piecefilter PieceFilter;
88	typedef struct prunedata PruneData;	88	typedef struct prunedata PruneData;
89	typedef struct solveoptions SolveOptions;	89	typedef struct solveoptions SolveOptions;
90	typedef struct step Step;	90	typedef struct step Step;
91	typedef struct symdata SymData;	91	typedef struct symdata SymData;
92	typedef struct threaddata ThreadData;	92	typedef struct threaddatasolve ThreadDataSolve;
		93	typedef struct threaddatagenpt ThreadDataGenpt;
93		94
94	typedef Cube (*AntiIndexer) (uint64_t);	95	typedef Cube (*AntiIndexer) (uint64_t);
95	typedef bool (*Checker) (Cube);	96	typedef bool (*Checker) (Cube);
@@ -108,221 +109,233 @@ typedef int (TransFinder) (uint64_t, Trans );
108	struct	109	struct
109	alg	110	alg
110	{	111	{
111	Move * move;	112	Move * move;
112	bool * inv;	113	bool * inv;
113	int len;	114	int len;
114	int allocated;	115	int allocated;
115	};	116	};
116		117
117	struct	118	struct
118	alglist	119	alglist
119	{	120	{
120	AlgListNode * first;	121	AlgListNode * first;
121	AlgListNode * last;	122	AlgListNode * last;
122	int len;	123	int len;
123	};	124	};
124		125
125	struct	126	struct
126	alglistnode	127	alglistnode
127	{	128	{
128	Alg * alg;	129	Alg * alg;
129	AlgListNode * next;	130	AlgListNode * next;
130	};	131	};
131		132
132	struct	133	struct
133	block	134	block
134	{	135	{
135	bool edge[12];	136	bool edge[12];
136	bool corner[8];	137	bool corner[8];
137	bool center[6];	138	bool center[6];
138	};	139	};
139		140
140	struct	141	struct
141	command	142	command
142	{	143	{
143	char * name;	144	char * name;
144	char * usage;	145	char * usage;
145	char * description;	146	char * description;
146	ArgParser parse_args;	147	ArgParser parse_args;
147	Exec exec;	148	Exec exec;
148	};	149	};
149		150
150	struct	151	struct
151	commandargs	152	commandargs
152	{	153	{
153	bool success;	154	bool success;
154	Alg * scramble;	155	Alg * scramble;
155	SolveOptions * opts;	156	SolveOptions * opts;
156	Step * step;	157	Step * step;
157	Command * command; /* For help */	158	Command * command; /* For help */
158	};	159	};
159		160
160	struct	161	struct
161	coordinate	162	coordinate
162	{	163	{
163	Indexer index;	164	Indexer index;
164	AntiIndexer cube;	165	AntiIndexer cube;
165	uint64_t max;	166	uint64_t max;
166	TransFinder trans;	167	TransFinder trans;
167	};	168	};
168		169
169	struct	170	struct
170	cube	171	cube
171	{	172	{
172	int epose;	173	int epose;
173	int eposs;	174	int eposs;
174	int eposm;	175	int eposm;
175	int eofb;	176	int eofb;
176	int eorl;	177	int eorl;
177	int eoud;	178	int eoud;
178	int cp;	179	int cp;
179	int coud;	180	int coud;
180	int cofb;	181	int cofb;
181	int corl;	182	int corl;
182	int cpos;	183	int cpos;
183	};	184	};
184		185
185	struct	186	struct
186	cubearray	187	cubearray
187	{	188	{
188	int * ep;	189	int * ep;
189	int * eofb;	190	int * eofb;
190	int * eorl;	191	int * eorl;
191	int * eoud;	192	int * eoud;
192	int * cp;	193	int * cp;
193	int * coud;	194	int * coud;
194	int * corl;	195	int * corl;
195	int * cofb;	196	int * cofb;
196	int * cpos;	197	int * cpos;
197	};	198	};
198		199
199	struct	200	struct
200	dfsdata	201	dfsdata
201	{	202	{
202	int d;	203	int d;
203	int m;	204	int m;
204	int lb;	205	int lb;
205	bool niss;	206	bool niss;
206	Move last1;	207	Move last1;
207	Move last2;	208	Move last2;
208	EstimateData * ed;	209	EstimateData * ed;
209	AlgList * sols;	210	AlgList * sols;
210	pthread_mutex_t * sols_mutex;	211	pthread_mutex_t * sols_mutex;
211	Alg * current_alg;	212	Alg * current_alg;
212	Move * sorted_moves;	213	Move * sorted_moves;
213	int * move_position;	214	int * move_position;
214	uint8_t * visited;	215	uint8_t * visited;
215	};	216	};
216		217
217	struct	218	struct
218	estimatedata	219	estimatedata
219	{	220	{
220	Cube cube;	221	Cube cube;
221	int target;	222	int target;
222	Move lastmove;	223	Move lastmove;
223	uint64_t movebitmask;	224	uint64_t movebitmask;
224	LocalInfo * li;	225	LocalInfo * li;
225	};	226	};
226		227
227	struct	228	struct
228	localinfo	229	localinfo
229	{	230	{
230	int corners;	231	int corners;
231	int normal_ud;	232	int normal_ud;
232	int normal_fb;	233	int normal_fb;
233	int normal_rl;	234	int normal_rl;
234	int inverse_ud;	235	int inverse_ud;
235	int inverse_fb;	236	int inverse_fb;
236	int inverse_rl;	237	int inverse_rl;
237	int prev_ret;	238	int prev_ret;
238	};	239	};
239		240
240	struct	241	struct
241	piecefilter	242	piecefilter
242	{	243	{
243	bool epose;	244	bool epose;
244	bool eposs;	245	bool eposs;
245	bool eposm;	246	bool eposm;
246	bool eofb;	247	bool eofb;
247	bool eorl;	248	bool eorl;
248	bool eoud;	249	bool eoud;
249	bool cp;	250	bool cp;
250	bool coud;	251	bool coud;
251	bool cofb;	252	bool cofb;
252	bool corl;	253	bool corl;
253	bool cpos;	254	bool cpos;
254	};	255	};
255		256
256	struct	257	struct
257	prunedata	258	prunedata
258	{	259	{
259	char * filename;	260	char * filename;
260	uint8_t * ptable;	261	uint8_t * ptable;
261	bool generated;	262	bool generated;
262	uint64_t n;	263	uint64_t n;
263	Coordinate * coord;	264	Coordinate * coord;
264	Moveset moveset;	265	Moveset moveset;
265	};	266	};
266		267
267	struct	268	struct
268	solveoptions	269	solveoptions
269	{	270	{
270	int min_moves;	271	int min_moves;
271	int max_moves;	272	int max_moves;
272	int max_solutions;	273	int max_solutions;
273	int nthreads;	274	int nthreads;
274	bool optimal_only;	275	bool optimal_only;
275	bool can_niss;	276	bool can_niss;
276	bool verbose;	277	bool verbose;
277	bool all;	278	bool all;
278	bool print_number;	279	bool print_number;
279	};	280	};
280		281
281	struct	282	struct
282	step	283	step
283	{	284	{
284	char * shortname;	285	char * shortname;
285	char * name;	286	char * name;
286	Estimator estimate;	287	Estimator estimate;
287	Checker ready;	288	Checker ready;
288	char * ready_msg;	289	char * ready_msg;
289	Validator is_valid;	290	Validator is_valid;
290	Moveset moveset;	291	Moveset moveset;
291	Trans pre_trans;	292	Trans pre_trans;
292	TransDetector detect;	293	TransDetector detect;
293	int ntables;	294	int ntables;
294	PruneData * tables[10];	295	PruneData * tables[10];
295	};	296	};
296		297
297	struct	298	struct
298	symdata	299	symdata
299	{	300	{
300	char * filename;	301	char * filename;
301	bool generated;	302	bool generated;
302	Coordinate * coord;	303	Coordinate * coord;
303	Coordinate * sym_coord;	304	Coordinate * sym_coord;
304	int ntrans;	305	int ntrans;
305	Trans * trans;	306	Trans * trans;
306	uint64_t * class;	307	uint64_t * class;
307	Cube * rep;	308	Cube * rep;
308	Trans * transtorep;	309	Trans * transtorep;
309	};	310	};
310		311
311	struct	312	struct
312	threaddata	313	threaddatasolve
313	{	314	{
314	int thid;	315	int thid;
315	Cube cube;	316	Cube cube;
316	Step * step;	317	Step * step;
317	int depth;	318	int depth;
318	Move * sorted_moves;	319	Move * sorted_moves;
319	int * move_position;	320	int * move_position;
320	SolveOptions * opts;	321	SolveOptions * opts;
321	AlgList * start;	322	AlgList * start;
322	AlgListNode ** node;	323	AlgListNode ** node;
323	AlgList * sols;	324	AlgList * sols;
324	pthread_mutex_t * start_mutex;	325	pthread_mutex_t * start_mutex;
325	pthread_mutex_t * sols_mutex;	326	pthread_mutex_t * sols_mutex;
		327	};
		328
		329	struct
		330	threaddatagenpt
		331	{
		332	int thid;
		333	PruneData * pd;
		334	int d;
		335	uint64_t rangemin;
		336	uint64_t rangemax;
		337	int nchunks;
		338	pthread_mutex_t ** mutex;
326	};	339	};
327		340
328	#endif	341	#endif