dataesr/scientific-paragraphs-categorization huggingface dataset:
Since objtool is intimately bound to the Linux kernel, its analysis is tailored for control structures and coding conventions used in the kernel; for instance only indirect jumps arising from compilation of switch statements are supported, and there are symbol-table related restrictions on targets of call instructions. Performance-wise, the parsing ORC tables is much simpler than DWARF tables, and ORC-based unwinding is reported to be faster that DWARF-based unwinding; the ORC documentation mentions a factor of 20, but the methodology used to measure this speedup is not documented. As eh_elfs, ORC tables are stored off-band in the. orc_unwind and. orc_unwind_ip tables; ORC tables are reported to take about 50% more RAM space than DWARF-based. eh_frame tables. Although DWARF informations can be seen as analogue to stack maps studied in the garbage collector literature, stack maps are used to identify accurately stack-allocated pointers.
FUTURE DIRECTIONS In this paper we have designed and implemented techniques to validate or synthesise. eh_frame unwind tables, and to speed-up DWARF-based unwinding. Additionally we hope that this paper has illustrated some inner working of DWARF debug information, a central component of our computing infrastructure mostly ignored by the research community. Apart for the academic contribution, our long term aim is to integrate these tools in the wide low-level software ecosystem. For this some engineering work might be needed, for instance a faster validator might be implemented by instrumenting the QEMU machine emulator rather than relying on gdb, and tools might be ported to other architectures or ABIs. We thus conclude this paper with the following summary of our findings, highlighting the directions we are currently investigating.
• We showed that the. eh_frame validation tool, combined with the CSmith fuzzer, proved effective to identify bugs in the LLVM x86_64 backend. We also realised some preliminary testing of the glibc test suite, identifying one issue in subtle inline assembly code. Our aim is to make this testing part of the standard test-suites both of compilers and of code relying extensively on inline assembly code, as it improves on the rudimentary testing strategies used now; • We showed that synthesis of. eh_frame tables is possible and effective. This synthesis strategy is of interest to both language implementors and debugger developers. Synthesis might be integrated in the inline-assembly support of mainstream compilers, so that correct. eh_frame tables can be generated without requiring the error prone task of specifying unwinding information in inline-assembly snippets.
Synthesis might also be invoked on demand by debuggers and program analysis tools to analyse binaries that lack unwind tables, most notably JITted code. • Speeding up DWARF based unwinding is valuable for the wider audience of tools and libraries that need to efficiently unwinding the stack (including profilers or language runtimes). Discussion is currently ongoing with developers of the perf profiler to enable part of the profiler call-stack analysis to be done online, with the benefit that the final perf. data file would not contain any sensitive information anymore. The same way, we define reg --→ that extracts the rule currently applied for %reд in the last row of a FDE, e. g. F.
Experimental Setup The performance of the proposed watermarked method in terms of imperceptibility and robustness is tested on several 3D objects: Bunny (34, 835 vertices, 69, 666 facets), Horse (112, 642 vertices, 225, 280 facets), Venus (100, 759 vertices, 201, 514 facets), Armadillo (26, 002 vertices, 52, 000 facets), Rabbit (70, 658 vertices, 141, 312 facets), Flower (2523 vertices, 4895 facets), Vase (2527 vertices, 5004 facets), Cup (9076 vertices, 18, 152 facets), Ant (7654 vertices, 15, 304 facets), Bimba (8857 vertices, 17, 710 facets), and Cat (3534 vertices, 6975 facets). LIRIS/EPFL General-Purpose  [20]  database was created in Switzerland and contains 88 models in total. It contains 4 reference models which are Armadillo, Dyno, venus and RockerArm. The subjective evaluation was done by 12 observers.
The distortions that the reference mesh undergoes are smoothing and noise addition. We note that the scores are between 0 referring to good quality and 10 representing a bad quality. For each mesh, the average of the scores given by the 12 observers is computed in order to have a normalized mean opinion score (MOS). The LIRIS Masking database was created at the University of Lyon in France and contains 26 models, and the subjective evaluation was done by 11 observers  [21]. Only some objects are taken from the two mentioned databases. The model sizes are provided in Table  1. Figure  6a ,c,e show an example of three original 3D objects. The quantization step is tuned experimentally in such a way that ensures the best tradeoff between imperceptibility and robustness. To do so, extensive experiments have been conducted (see Figures  7 8 9 ) using several empirically different values of ∆.
The memoization technique can be integrated into any C or C++ application that has memoizable functions or methods. Based on the selected memoizable functions, our framework generates a new version of the application enhanced with memoization support by relying on the Clava 1  source-tosource compiler. The framework is also responsible to generate the C library that contains the core of the memoization implementation, which is linked with the newly generated application. The compilation process of Clava is controlled by the LARA  [5]  Domain-Specific Language (DSL). With this setup, it is also possible to use LARA to perform analyses and transformations on the code, e. g. , where and how to apply the memoization technique in this specific case. The main modular unit in LARA code is the aspect, which can be considered as a function, with input and outputs, but that has the capability of interacting with the internal representation of the application source code.
Software description The software solution presented in this paper relies on two different components which are combined to easily enhance an application with memoization support. The first component is Clava, a source-to-source compiler able to automatically generate a new version of the application code with the necessary changes to support memoization. This is performed through a series of LARA aspects the user can call and parameterize, all distributed as part of the Clava memoization library. The second component is the memoization C library itself, which is generated from a configuration file that identifies the functions on which to apply memoization. The library is compiled and linked against the version of the input application that has been modified by Clava. As shown in Figure  1 , the use of this memoization solution consists of three steps: 1) source-to-source compilation; 2) generation and compilation of the memoization library; and 3) compilation of the application linked with library.
In this article, we propose the use of memoization through Clava, by relying on aspects programmed with the LARA DSL. However, it is also possible to use the standalone library 2  without relying on LARA and the Clava compiler. To do so, the user must manually write the function identifications file (funs-static. def), change the source code to include the wrappers and replace calls from the original calls to the wrappers. The rest of the flow remains the same: generate the library and link it when compiling the application. The advantage of using LARA strategies is that the memoization library is integrated into the application without performing manual modifications of the source code. The code generated by Clava is then compiled and linked with the associated generated memoization library.
Software Architecture The Library Generator is a sed script that takes the function definitions file (*. def) and several code templates to generate the final customized code of the memoization library. This code can then be compiled into a library. The library itself maintains a table for each memoized function as well as the associated variables for runtime control and the interface functions. These are the functions called from each of the wrappers inserted with the Clava memoization strategies. The final application retains the original functionality. In the source code, the difference is that it has a wrapper for each target function. This wrapper is called instead of the original and performs calls to the generated memoization library.
Illustrative Examples This section presents an example of a LARA aspect that illustrates the interface between the user and the memoization library described in the previous section. Consider an example of a C application that uses the mathematical functions cos, acos and sqrt. Moreover, the profiling of the application shows that there is a large number of calls to a user function called myfunc. Figure  5  shows a LARA aspect, named Launcher, that can be used to apply memoization. First, we import the class that contains the memoization aspects (line 1). Then, the functions to be memoized are identified (lines 5-6), preceded by an initialization (line 4) and followed by a finalization stage (line 7). This is all the LARA code user needs to write to enhance a C/C++ application with memoization.
However, in the specific case of atmi, the Bessel functions show an increasing number of collisions when updating is enabled, which seems to indicate that two frequent inputs are colliding and continually pushing each other off the table, causing misses and forcing the recalculation of their corresponding outputs. The fft benchmark shows a performance degradation when using memoization without updates, regardless of the table size. When looking at more detailed execution data (not presented here), it is possible to see that there is a single hit for cos (out of 200,000,000 calls) and 0 hits for sin (out of 100,000,000 calls). This means the tables are initially filled with inputs that are not requested again in the future, causing an overhead which slightly degrades the original performance.
Problem Statement and Model We consider a classification dataset B 0 with n observations B 0 = {(x i , c i )} n i=1 , (1) obtained from a physical signal, or synonymously, explanatory variables, objects, instances, cases, patterns, t-uples, etc. where each x i belongs to class c i ∈ {C 1 ,. , C K }. The vector x i lies in an attribute space A ∈ R p and each component x ij is a numerical or nominal categorical attribute, also named feature, variable, dimension, component, field, etc. The output of the M classifiers K 1 (x),. , K M (x) are represented by a K-dimensional vector u i (x) = (u i1 ,. , u iK ) T , 1 ≤ i ≤ m: each component u ij is a certain value associated with class C j given by K i (x). Depending on the nature of the classifier K i (x), u ij can be a rank value that reflects a complete or partial ordering of all classes, or a value in {0, 1} corresponding to the predicted class assigned to 1 and the others to zero, or a score, e.
t. δ ij = K ∑ k=1 y (k) ij , y ij + y ji = 1, i < j, y ii = 0∀i y ij + y ji -y ik ≤ 1, ∀i = j = k, y ij ∈ {0, 1}. (25) From a machine learning perspective, solving Equations (  19 ) and (  25 ) provides deterministic matrix solutions P * and Y * , respectively, from which r * is easily reconstructed, but these solutions are not necessarily identical  [28]. Example 3 (Classifier ensemble aggregation rule). The problem selected to illustrate our theory is that of combining four classifiers for recognizing handwritten digits 0 to 9. Binary images from the MNIST database are used  [33]. The four classifiers are tested on a sample and proposed rankings are collected in Table  2. The two rankings are concordant except for the predictions for digits 5 and 6.
The Dataset The cytological dataset is constituted of smear images from 14 different women. They generally comprise more than one hundred cells characterized by 42 morphological or textural variables. Nine showed a negative HPV test and the other five, a positive test. In addition, few observations were labeled by an expert who pointed out some atypical cells and noisy objects. The dataset is presented in detail in Table  3. Among the most recurrent patterns of abnormal cells are nucleus regularity or a swollen aspect, nucleus size, important optical density, number of nucleoli, high core/cytoplasm ratio, ratio of minimum/maximum width of the nucleus, etc. The images were colored with Papanicolaou stain, which is the most widely used reference color for the screening of cervical cancers; it makes it possible to distinguish the different nuclei, which are colored in blue, the mother cells in dark purple to black, and the keratinized and squamous epithelium.
The low proportion of the target class and the heterogeneity of the debris present obstacles for clustering. This means that, among the cells belonging to risky patient smears, there exists a non-null risk that some nuclei are atypical. Iin practice, this proportion is usually very low (0. 1% to 5%). From this image segmentation, morphological and photometric features are extracted and computed. In total, the studied dataset has 3857 cell samples belonging to 14 different smears and consists of 42 variables: variables 1 to 19 represent morphological variables, and the rest corresponds to textural and photometric characters. The channel of treatments from the smear image to the dataset is reported in Figure  5. Each smear was pre-processed according to a standardized protocol: cell collection, spreading a thin layer on slides, and the staining of these slides.
Implementation and Experiments To evaluate the QCHR approach, three well known problems  3  are modelled and solved in QCSP and QCHR. Then, the results obtained by two solvers are compared: QuaCode  [3]  for the solving of the QCSP models and our solver Q CHR++ for the solving of the QCHR models. Q CHR++ is a QCHR solver based on the CHR++ solver  4. The latter has been extended by adding two new items to its grammar: exists and forall. Item exists allows you to browse the domain of a variable by successively trying each of its values in search of success. Item forall makes it possible to browse the domain of a variable by making sure that each of the values leads to a success. They implement the ∃-elimination and ∀-elimination rules previously defined. Each experiment has been run 10 times and the average of the running times and number of failures are reported in the tables.
Notice that there is no random parameter or value used for both solvers. As a consequence, for a given instance, the number of failures is always the same and the standard deviation of the running times is quite low. All experiments have been run on an Intel Xeon-E5, 2. 1-3. 3GHz, 128GB RAM running Linux. Maximum computation time is set to 300 seconds. All benchmarks used here are provided with CHR++ sources. The matrix game is a two-players game of d turns. It is played on a 0/1 square matrix of size 2 d. At each turn, player A cuts the matrix in half horizontally and decides to keep the top or bottom part. Player B then cuts the matrix in half vertically and keeps the left or right part. If the last cell contains a 1, player A wins. The matrix game is well suited to the QCSP approach because the binder does not take benefit from being defined dynamically.
Indeed, the number of moves of a matrix game is fixed and only depends on the matrix size. Although it does not belong to our motivating examples, it is used as a use case to evaluate the efficiency of our approach on static binders. Let M be the input matrix of size 2 d such that M[i, j] ∈ {0, 1}, i, j ∈ [0; √ 2 d -1]. The following QCHR program finds a winning strategy to the matrix game: u @ \mgu(d)<∀>[it, 0, 1] updateCorner ∀ (it), mge(d -1) e 0 @ mge(0) ⇔ M[CornerUL x ,CornerUL y ] = 1 e @ \mge(d)<∃>[it, 0, 1] updateCorner ∃ (it), mgu(d -1) With CornerUL and CornerLR the coordinates of the upper left and lower right corners of the relevant part of the matrix. The relevant part is the remaining part after a player turn. Constraints updateCorner ∀ () The matrix game has already been modeled as a QCSP and solved with a QCSP solver.
Random matrices are used as input for the instances and computed the average execution time and number of failures of each solver. Results are reported in Table  1. Both models are quite equivalent and the solving takes no benefit from propagation of QCSP constraints. The number of failures encountered by QuaCode is smaller than that of Q CHR++. Indeed, the propagation done in QuaCode prevents the last branching steps of search. But the cost is huge compared to the price of propagating the previous choices during the whole search. In comparison, Q CHR++ does not propagate the choices thanks to the constraints but its model is quite simple to test and each basic operation is constant in time. Indeed, it only has to update the corner variables and to check at the end if it is a 1 or a 0. That is why Q CHR++ is able to solve the instance of depth 10 while QuaCode reaches the time limit.
As a result, we show that the QCHR model combined with Q CHR++ is lighter and can be more efficient than a QCSP model with QuaCode. The Nim game is our first motivating example which has been introduced in Section 2. It can be modeled in QCHR in a very intuitive way. But the QCHR model can do even more. Indeed, thanks to its dynamic way of modeling, it is possible to make a top-down evaluation with tabling  [24]. A topdown evaluation with tabling consists in storing states of sub-trees already explored. If such a sub-tree is encountered another time, its result will be used instead of exploring it again. For the experiments, we compare three solving approaches: QuaCode for the QCSP/QCSP+ solving, Q CHR++ for the QCHR solving and Q CHR++ (Mem) for the solving of the QCHR model with tabling.
We first observe on Figure  1  that QuaCode cannot solve instances of more than 40 matches without exceeding the time limit (i. e. 300s). We notice that QuaCode and Q CHR++ encountered the same number of failures. Indeed, they are both based on same model and there is no constraint to propagate. But, as seen on Figure  1 , Q CHR++ performs better. We now compare with Q CHR++ with tabling and see on Figure  1  that all instances are solved in less than 1 second. This huge improvement is explained by the tabling process. Indeed, a Nim game state 5  can be encountered many times during the search. Recording such states will prevent the algorithm to explore them again in the future and increases a lot the efficiency of the search. As the current state of a Nim game is Markovian (i. e. the current state does not depend on the whole history of events), similar results are achieved in  [22].
The connect-four game is our second motivating example. It has been presented at Section 2. The QCSP+ model for the connect-four is big and not very understandable compared to the QCHR model. The QCHR model involves a dynamic binder which is built during the solving. For the experiments, QuaCode for the QCSP solving and Q CHR++ for the QCHR solving are compared. As shown Table  2 , the number of failures encountered by QuaCode is smaller than that of Q CHR++. Indeed, as for the matrix game, the propagation done in QuaCode prevents the last branching steps of search. But the cost is huge compared to the benefit of avoiding a few branching steps. The results show that Q CHR++ performs better than QuaCode. It is more than 50 times faster and can even find solution before the time limit on the last instance.
INTRODUCTION According to many scientists, one way to describe Artificial Intelligence (AI) is as the study of agents that receive percepts from, plan and perform actions in the environment. The main unifying theme underlying AI is then the idea of an intelligent agent able to reason, plan, act, interact, and learn  [38]. This metaphor makes intelligent agents appealing for a wide audience interested in classical and distributed AI, agents and multi-agent systems (MAS) engineering, machine learning, and decentralized systems. Despite the substantial body of knowledge and expertise developed in the design and development of MAS, the systematic engineering of large-scale and open MAS still poses many challenges. Even though various languages, models, techniques and methodologies have been proposed, researchers and developers still face fundamental questions attaining the engineering of MAS, and more in detail foundational theories, architectures, languages, processes, and platforms for designing, implementing, running, maintaining and evolving MAS.
In this context, interesting questions to be addressed are: • How to express the requirements for large-scale and open MAS and how to translate these requirements into agent goals? • Which architectures are most suitable for MAS of different domains? • How to seamlessly integrate AI and machine learning techniques into design/programming languages and tools for agent-based systems? • How to specify, design, implement, verify, test, validate and evolve MAS? • How to enable agent-based systems to deal with continuous change, for example in the operating environment or user requirements? • How to ensure/control global behavior of decentralized MAS? • How to seamlessly integrate MAS engineering with mainstream engineering models, languages, frameworks and tools? • What are the implications of MAS engineering in the context of continuous development and deployment? • What is the synergy between Cloud and Edge computing on the one hand and MAS engineering on the other hand? • How to scale with the complexity of real-world application domains? • How can MAS help developing Cyber-Physical Systems and Internet of Things (IoT)? • Which tools and frameworks are available/needed? • Which processes are required for fast but high-quality development of MAS? EMAS 2018 zoomed in into several of these questions through an invited talk, focused presentations, panels, and discussion groups.
EMAS WORKSHOP EMAS 2018 took place in Stockholm, Sweden, on 14th-15th of July, 2018. It aimed to gather researchers and engineers with an interest in software engineering (SE) and programming of MAS, declarative agent languages and technologies, machine learning, and other AI-related topics to present and discuss their research and emerging results in MAS engineering. The overall purpose of this workshop was to facilitate the cross-fertilization of ideas and experiences in the various fields to: 1. enhance our knowledge and expertise in MAS engineering and improve the state-of-the-art; 2. define new directions for MAS engineering that are useful to practitioners, relying in results and recommendations coming from different but continuous research areas; 3. investigate how practitioners can use or adapt established processes and methodologies for the engineering of largescale and open MAS; 4.
Relying on such optional behaviors carries the risk that the behavior of a Jason program cannot be understood by examining its source code alone. Alessandro Ricci, Rafael H. Bordini, Jomi F. Hubner and Rem Collier present "AgentSpeak(ER): Enhanced Encapsulation in Agent Plans". AgentSpeak(ER) extends AgentSpeak(L)  [36]  to support encapsulation and allows for improving the style of Belief-Desire-Intentions (BDI) agent programming along relevant aspects, including program modularity and readability, failure handling, and reactive as well as goal-based reasoning. AgentSpeak(ER) has been implemented and experimentally evaluated on top of the ASTRA  [13]  platform and an implementation in Jason is under way.