You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

60 lines
1.2 KiB

/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/* allocation that cannot fail */
void* __llair_alloc(unsigned size);
/* non-deterministic choice */
int __llair_choice();
/* throw an exception */
__attribute__((noreturn)) void __llair_throw(void* thrown_exception);
/* executions that call __llair_unreachable are assumed to be impossible */
__attribute__((noreturn)) void __llair_unreachable();
/* glibc version */
#define __assert_fail(assertion, file, line, function) abort()
/* macos version */
#define __assert_rtn(function, file, line, assertion) abort()
[sledge] Add concurrency analysis Summary: This diff changes the analysis exploration algorithm from considering only sequential executions to considering executions of the interleaving semantics. As part of this, symbolic states are changed so that each thread has its own registers, while all memory is shared between them. Currently only a simple threads interface is supported: they can be created with `thread_create(&thread_routine)`, they can exit by returning from `thread_routine`, and they can be joined with `thread_join`. Current simplifications include that newly created threads are already runnable, thread routines accept no arguments and return no result, and no failures are possible. The concurrent exploration algorithm gives preference to executions which have fewer context switches, thereby performing an incremental form of context-bounded analysis. A form of partial-order reduction is performed, where the symbolic states are joined across (prefixes of) executions with the same number of context switches which reach a point where the instruction pointers and call stacks of all threads are the same. This has the effect of "dagifying" the concurrent execution tree by merging points after e.g. threads perform actions that commute with each other. This is unlike traditional partial-order reduction in that it relies on the symbolic join to combine the results of commuting operations in a way that the following symbolic execution can take advantage of, rather than performing some up-front analysis to identify commuting operations and quotienting the space of executions. The current state of the symbolic join and execution is significantly suboptimal in this regard. Differential Revision: D29441149 fbshipit-source-id: cf801a6b1
3 years ago
/*
* threads
*/
typedef int thread_t;
typedef void (*thread_create_routine)();
thread_t sledge_thread_create(thread_create_routine entry);
void sledge_thread_join(thread_t thread);
typedef uint32_t error_t;
error_t thread_create(thread_t** t, thread_create_routine entry) {
thread_t child = sledge_thread_create(entry);
**t = child;
return 0;
}
error_t thread_join(thread_t* t) {
sledge_thread_join(*t);
return 0;
}
#ifdef __cplusplus
}
#endif