ppxscal/embedding_network huggingface dataset:
Flexible support for multiple access control policies
Authors: Sushil Jajodia, Pierangela Samarati, Maria Luisa Sapino, V. S. Subrahmanian
Venue: ACM Transactions on Database Systems (TODS) (2001)

Although several access control policies can be devised for controlling access to information, all existing authorization models, and the corresponding enforcement mechanisms, are based on a specific policy (usually the closed policy). As a consequence, although different policy choices are possible in theory, in practice only a specific policy can actually be applied within a given system. In this paper, we present a unified framework that can enforce multiple access control policies within a single system. The framework is based on a language through which users can specify security policies to be enforced on specific accesses. The language allows the specification of both positive and negative authorizations and incorporates notions of authorization derivation, conflict resolution, and decision strategies. Different strategies may be applied to different users, groups, objects, or roles, based on the needs of the security policy. The overall result is a flexible and powerful, yet simple, framework that can easily capture many of the traditional access control policies as well as protection requirements that exist in real-world applications, but are seldom supported by existing systems. The major advantage of our approach is that it can be used to specify different access control policies that can all coexist in the same system and be enforced by the same security server.
Uniform Random Generation of Balanced Parenthesis Strings
Authors: D. B. Arnold, M. R. Sleep
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1980)

The empirical testing of error repair schemes for skeletons of source programs in a block-structured language leads to the problem of generating balanced parenthesis strings in a uniform random manner. An efficient generator which works from left to right must compute the correct probability for the next symbol at each stage of the generation. The associated enumeration problem may be solved by adopting a geometric interpretation usually associated with random walk problems. This solution leads immediately to an O(n) algorithm for the generator.
Plan Realization for Complex Command Interaction in the UNIX Help Domain
Authors: Stephen J. Hegner
Venue: Artificial Intelligence Review (2000)

Yucca-&ast; is a consultation system which is designed to provide the UNIX user, through a friendly interface, with detailed expert advice on the use of the UNIX command language. One of the principal design goals of this system is the ability to provide correct responses to technically complex queries whose solution may involve the interconnection of several commands, each with multiple options. The realization of such a goal requires two things. First, representation of dynamic knowledge about command behavior at a sufficient level of detail to support solution of the query is needed. Second, a planning mechanism capable of interconnecting such knowledge into a cohesive solution must be provided. This paper first develops the command dynamics representation techniques employed in Yucca-&ast;. It then examines in detail the plan generation mechanism which is used to solve complex dynamic queries. Particular emphasis is placed upon those aspects of the problem which are unique to this particular domain.
TACCLE: a methodology for object-oriented software testing at the class and cluster levels
Authors: Huo Yan Chen, T. H. Tse, T. Y. Chen
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (2001)

Object-oriented programming consists of several different levels of abstraction, namely, the algorithmic level, class level, cluster level, and system level. The testing of object-oriented software at the algorithmic and system levels is similar to conventional program testing. Testing at the class and cluster levels poses new challenges. Since methods and objects may interact with one another with unforeseen combinations and invocations, they are much more complex to simulate and test than the hierarchy of functional calls in conventional programs. In this paper, we propose a methodology for object-oriented software testing at the class and cluster levels. In class-level testing, it is essential to determine whether objects produced from the execution of implemented systems would preserve the properties defined by the specification, such as behavioral equivalence and nonequivalence. Our class-level testing methodology addresses both of these aspects. For the testing of behavioral equivalence, we propose to select fundamental pairs of equivalent ground terms as test cases using a black-box technique based on algebraic specifications, and then determine by means of a white-box technique whether the objects resulting from executing such test cases are observationally equivalent. To address the testing of behavioral nonequivalence, we have identified and analyzed several nontrivial problems in the current literature. We propose to classify term equivalence into four types, thereby setting up new concepts and deriving important properties. Based on these results, we propose an approach to deal with the problems in the generation of nonequivalent ground terms as test cases. Relatively little research has contributed to cluster-level testing. In this paper, we also discuss black-box testing at the cluster level. We illustrate the feasibility of using contract, a formal specification language for the behavioral dependencies and interactions among cooperating objects of different classes in a given cluster. We propose an approach to test the interactions among different classes using every individual message-passing rule in the given Contract specification. We also present an approach to examine the interactions among composite message-passing sequences. We have developed four testing tools to support our methodology.
Related field analysis
Authors: Aneesh Aggarwal, Keith H. Randall
Venue: ACM SIGPLAN Notices (2001)

We present an extension of field analysis (sec [4]) called related field analysis which is a general technique for proving relationships between two or more fields of an object. We demonstrate the feasibility and applicability of related field analysis by applying it to the problem of removing array bounds checks. For array bounds check removal, we define a pair of related fields to be an integer field and an array field for which the integer field has a known relationship to the length of the array. This related field information can then be used to remove array bounds checks from accesses to the array field. Our results show that related field analysis can remove an average of 50% of the dynamic array bounds checks on a wide range of applications. We describe the implementation of related field analysis in the Swift optimizing compiler for Java, as well as the optimizations that exploit the results of related field analysis.
SystemC: a homogenous environment to test embedded systems
Authors: Alessandro Fin, Franco Fummi, Maurizio Martignano, Mirko Signoretto
Venue: Proceedings of the ninth international symposium on Hardware/software codesign (2001)

The SystemC language is becoming a new standard in the EDA field and many designers are starting to use it to model complex systems. SystemC has been mainly adopted to define abstract models of hardware/software components, since they can be easily integrated for rapid prototyping. However, it can also be used to describe modules at a higher level of detail, e.g., RT-level hardware descriptions and assembly software modules. Thus, it would be possible to imagine a SystemC-based design flow, where the system description is translated from one abstraction level to the following one by always using SystemC representations. The adoption of a SystemC-based design flow would be particularly efficient for testing purpose as shown in this paper. In fact, it allows the definition of a homogeneous testing procedure, applicable to all design phases, based on the same error model and on the same test generation strategy. Moreover, test patterns are indifferently applied to hardware and software components, thus making the proposed testing methodology particularly suitable for embedded systems. Test patterns are generated on the SystemC description modeling the system at one abstraction level, then, they are used to validate the translation of the system to a lower abstraction level. New test patterns are then generated for the lower abstraction level to improve the quality of the test set and this process is iterated for each translation (synthesis) step.
A Model for the Dynamic Interaction Between Evolution and Learning
Authors: Bernhard Sendhoff, Martin Kreutz
Venue: Neural Processing Letters (1999)

The interaction between learning and evolution has elicited much interest particularly among researchers who use evolutionary algorithms for the optimization of neural structures. In this article, we will propose an extension of the existing models by including a developmental phase &ndash; a growth process &ndash; of the neural network. In this way, we are able to examine the dynamical interaction between genetic information and information learned during development. Several measures are proposed to quantitatively examine the benefits and the effects of such an overlap between learning and evolution. The proposed model, which is based on the recursive encoding method for structure optimization of neural networks, is applied to the problem domain of time series prediction. Furthermore, comments are made on problem domains which associate growing networks (size) during development with problems of increasing complexity.
A comparative study of computer programs for integrating differential equations
Authors: Phyllis Fox
Venue: Communications of the ACM (1972)

A study comparing the performance of several computer programs for integrating systems of ordinary differential equations is reported. The integration methods represented include multistep methods (predictor-correctors), single-step methods (Runge-Kutta) and extrapolation methods (both polynomial and rational). The testing procedure is described together with the evaluation criteria applied. A set of test problems on which the programs were tested is included in an appendix. For the particular problems and criteria used in the investigation it was found that a program based on rational extrapolation showed the best performance.
From Washington: The STARS program
Authors: Rosalie Steier
Venue: Communications of the ACM (1983)

In 1979 the Department of Defense started its &ldquo;software initiative,&rdquo; an effort to maintain U.S. leadership in computer technology for support of its military systems. The &ldquo;software initiative&rdquo; evolved into the Software Technology for Adaptable Reliable Systems program (STARS), first outlined in the &ldquo;Strategy for a DoD Software Initiative&rdquo; in October 1982 and later refined in the &ldquo;STARS Program Strategy&rdquo; in March 1983. STARS is intended to address DoD software problems in the same way the Very High Speed Integrated Circuits1 program (VHSIC) is intended to ameliorate DoD hardware limitations in defense systems. The basic plan is a cooperative effort of government, industry, and academia in software technology. Industry is offered contractual incentives; both industry and academia are encouraged to contribute their best talent. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player
Moving up the food chain: supporting e-commerce applications on databases
Authors: Anant Jhingran
Venue: ACM SIGMOD Record (2000)

Database systems have enjoyed a tremendous market because they have served many applications really well -- transaction processing in the beginning, and then decision support. Today, with over 200% cumulative growth rate in certain segments of E-Commerce, it is clear that this new class of applications will be a strong driver for databases to grow, commercially, as well as from a Research perspective. This paper outlines some of the issues that I have learnt in dealing with E-Commerce applications that may well be the focus of some of the research in database systems over the course of next few years.
Efficient Compositing Methods for the Sort-Last-Sparse Parallel Volume Rendering System on Distributed Memory Multicomputers
Authors: Don-Lin Yang, Jen-Chih Yu, Yeh-Ching Chung
Venue: The Journal of Supercomputing (2001)

In the sort-last-sparse parallel volume rendering system on distributed memory multicomputers, one can achieve a very good performance improvement in the rendering phase by increasing the number of processors. This is because each processor can render images locally without communicating with other processors. However, in the compositing phase, a processor has to exchange local images with other processors. When the number of processors exceeds a threshold, the image compositing time becomes a bottleneck. In this paper, we propose three compositing methods to efficiently reduce the compositing time in parallel volume rendering. They are the binary-swap with bounding rectangle (BSBR) method, the binary-swap with run-length encoding and static load-balancing (BSLC) method, and the binary-swap with bounding rectangle and run-length encoding (BSBRC) method. The proposed methods were implemented on an SP2 parallel machine along with the binary-swap compositing method. The experimental results show that the BSBRC method has the best performance among these four methods.
A recursive formulation of Cholesky factorization of a matrix in packed storage
Authors: Bjarne Stig Andersen, Jerzy Waśniewski, Fred G. Gustavson
Venue: ACM Transactions on Mathematical Software (TOMS) (2001)

A new compact way to store a symmetric or triangular matrix called RPF for Recursive Packed Format is fully described. Novel ways to transform RPF to and from standard packed format are included. A new algorithm, called RPC for Recursive Packed Cholesky, that operates on the RPG format is presented. ALgorithm RPC is basd on level-3 BLAS and requires variants of algorithms TRSM and SYRK that work on RPF. We call these RP_TRSM and RP_SYRK and find that they do most of their work by calling GEMM. It follows that most of the execution time of RPC lies in GEMM. The advantage of this storage scheme compared to traditional packed and full storage is demonstrated. First, the RPC storage format uses the minimal amount of storage for the symmetric or triangular matrix. Second, RPC gives a level-3 implementation of Cholesky factorization whereas standard packed implementations are only level 2. Hence, the performance of our RPC implementation is decidedly superior. Third, unlike fixed block size algorithms, RPC, requires no block size tuning parameter. We present performance measurements on several current architectures that demonstrate improvements over the traditional packed routines. Also MSP parallel computations on the IBM SMP computer are made. The graphs that are attached in Section 7 show that the RPC algorithms are superior by a factor between 1.6 and 7.4 for order around 1000, and between 1.9 and 10.3 for order around 3000 over the traditional packed algorithms. For some architectures, the RPC performance results are almost the same or even better than the traditional full-storage algorithms results.
A community and knowledge building model in computer education
Authors: Ken Eustace, Lyn Hay
Venue: Proceedings of the Australasian conference on Computing education (2000)

Computer Supported Collaborative Work (CSCW) is a new information technology subject at Charles Sturt University, that develops a learning community and knowledge sharing network for a diverse range of students. By integrating course content about CSCW, students use information environments and groupware products such as e-mail, the Z Object Publishing Environment (ZOPE) and MOO to create learning artefacts. The subject immerses students into social, philosophical and psychological aspects of working in online environments as well as the technology issues associated with being a participant in a workgroup that can be applied in such fields as professional development, information technology, library science, education, teacher librarianship, health care or policing. Students explore the principles of workgroups, various cognitive frameworks and collaborative task (eg. meetings, document generation, argument support and policy work). They learn how to select and tailor a framework appropriate to a specific collaborative situation, and guide the development of workgroup-specific infrastructure. They are also expected to evaluate the effectiveness of workflow, human interaction and knowledge management within an organisation. This paper describes how a team-teaching approach has been structured, and how students and lecturers facilitated each other in regard to course content, methods of instruction, methods of assessment and evaluation.
Backtracking in a Generalized Control Setting
Authors: Gary Lindstrom
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1979)

Backtracking is a powerful conceptual and practical programming language control structure. However, its application in general has been limited to global control over recursive programs. In this paper we explore the coherence and utility of applying backtracking in a more general control setting, namely, block-structured coroutines. The following criteria are proposed for such a control combination to be judged successful: (i) retention of each control form's individual semantics; (ii) coherent semantics for each legal application of the combination; (iii) nonpreeminence of either control form, and (iv) facilitation of genuinely novel programming effects. The attainability of these criteria is assessed, with the aid of an informal language design and three illustrative applications: (i) a dual tree walk program using coroutine-managed backtracking subsystems; (ii) a context-free language intersection tester using bilevel hierarchical backtracking, and (iii) an optimizing computer job scheduler using backtracking in a simulation language context. Full programs are given for each example, phrased in a Pascal extension offering both coroutines and backtracking (expressed through nondeterministic control).
Thinning algorithms on rectangular, hexagonal, and triangular arrays
Authors: E. S. Deutsch
Venue: Communications of the ACM (1972)

In this report three thinning algorithms are developed: one each for use with rectangular, hexagonal, and triangular arrays. The approach to the development of each algorithm is the same. Pictorial results produced by each of the algorithms are presented and the relative performances of the algorithms are compared. It is found that the algorithm operating with the triangular array is the most sensitive to image irregularities and noise, yet it will yield a thinned image with an overall reduced number of points. It is concluded that the algorithm operating in conjunction with the hexagonal array has features which strike a balance between those of the other two arrays.
Hardware/software instruction set configurability for system-on-chip processors
Authors: Albert Wang, Earl Killian, Dror Maydan, Chris Rowen
Venue: Proceedings of the 38th annual Design Automation Conference (2001)

New application-focused system-on-chip platforms motivate new application-specific processors. Configurable and extensible processor architectures offer the efficiency of tuned logic solutions with the flexibility of standard high-level programming methodology. Automated extension of processor function units and the associated software environment - compilers, debuggers, simulators and real-time operating systems - satisfies these needs. At the same time, designing at the level of software and instruction set architecture significantly shortens the design cycle and reduces verification effort and risk. This paper describes the key dimensions of extensibility within the processor architecture, the instruction set extension description language and the means of automatically extending the software environment from that description. It also describes two groups of benchmarks, EEMBC's Consumer and Telecommunications suites, that show 20 to 40 times acceleration of a broad set of algorithms through application-specific instruction set extension, relative to high performance RISC processors.
Buddy systems
Authors: James L. Peterson, Theodore A. Norman
Venue: Communications of the ACM (1977)

Two algorithms are presented for implementing any of a class of buddy systems for dynamic storage allocation. Each buddy system corresponds to a set of recurrence relations which relate the block sizes provided to each other. Analyses of the internal fragmentation of the binary buddy system, the Fibonacci buddy system, and the weighted buddy system are given. Comparative simulation results are also presented for internal, external, and total fragmentation.
Fractal symbolic analysis
Authors: Nikolay Mateev, Vijay Menon, Keshav Pingali
Venue: Proceedings of the 15th international conference on Supercomputing (2001)

Modern compilers perform wholesale restructuring of programs to improve their efficiency. Dependence analysis is the most widely used technique for proving the correctness of such transformations, but it suffers from the limitation that it considers only the memory locations read and written by a statement, and does not assume any particular interpretation for the operations in that statement. Exploiting the semantics of these operations permits more transformations to be proved correct, and is critical for automatic restructuring of codes such as LU with partial pivoting. One approach to exploiting the semantics of program operations is symbolic analysis and comparison of programs. In principle, this technique is very powerful, but in practice, it is intractable for all but the simplest programs. In this paper, we propose a new form of symbolic analysis and comparison of programs which is appropriate for use in restructuring compilers. Fractal symbolic analysis compares a program and its transformed version by repeatedly simplifying these programs until symbolic analysis becomes tractable while ensuring that equality of the simplified programs is sufficient to guarantee equality of the original programs. Fractal symbolic analysis combines some of the power of symbolic analysis with the tractability of dependence analysis. We discuss a prototype implementation of fractal symbolic analysis, and show how it can be used to solve the long-open problem of verifying the correctness of transformations required to improve the cache performance of LU factorization with partial pivoting.
The Story of Unified Cordic
Authors: John Stephen Walther
Venue: Journal of VLSI Signal Processing Systems (2000)

The story is told of how the Unified Cordic algorithm came to be developed, starting from an idea in the mind of a student and culminating in a product, a patent, a paper, a motorcade, and an award. Along the way, a unified algorithm for generating the elementary functions and the math co-processor industry in Silicon Valley were born.