B-LOG: A branch and bound methodology for the parallel execution of logic programs

We propose a computational methodology -"B-LOG"-, which offers the potential for an effective implementation of Logic Programming in a parallel computer. We also propose a weighting scheme to guide the search process through the graph and we apply the concepts of parallel "branch and bound" algorithms in order to perform a "best-first" search using an information theoretic bound. The concept of "session" is used to speed up the search process in a succession of similar queries. Within a session, we strongly modify the bounds in a local database, while bounds kept in a global database are weakly modified to provide a better initial condition for other sessions. We also propose an implementation scheme based on a database machine using "semantic paging", and the "B-LOG processor" based on a scoreboard driven controller

Towards an HLA Run-time Infrastructure with Hard Real-time Capabilities

Our work takes place in the context of the HLA standard and its application in real-time systems context. The HLA standard is inadequate for taking into consideration the different constraints involved in real-time computer systems. Many works have been invested in order to providing real-time capabilities to Run Time Infrastructures (RTI) to run real time simulation. Most of these initiatives focus on major issues including QoS guarantee, Worst Case Transit Time (WCTT) knowledge and scheduling services provided by the underlying operating systems. Even if our ultimate objective is to achieve real-time capabilities for distributed HLA federations executions, this paper describes a preliminary work focusing on achieving hard real-time properties for HLA federations running on a single computer under Linux operating systems. Our paper proposes a novel global bottom up approach for designing real-time Run time Infrastructures and a formal model for validation of uni processor to (then) distributed real-time simulation with CERTI

Online paging and file caching with expiration times

AbstractWe consider a paging problem in which each page is assigned an expiration time at the time it is brought into the cache. The expiration time indicates the latest time that the fetched copy of the page may be used. Requests that occur later than the expiration time must be satisfied by bringing a new copy of the page into the cache. The problem has applications in caching of documents on the World Wide Web (WWW). We show that a natural extension of the well-studied least recently used (LRU) paging algorithm is strongly competitive for the uniform retrieval cost, uniform size case. We then describe a similar extension of the recently proposed Landlord algorithm for the case of arbitrary retrieval costs and sizes, and prove that it is strongly competitive. The results extend to the loose model of competitiveness as well

Approximation Results for Preemptive Stochastic Online Scheduling

We present first constant performance guarantees for preemptive stochastic scheduling to minimize the sum of weighted completion times. For scheduling jobs with release dates on identical parallel machines we derive policies with a guaranteed performance ratio of 2 which matches the currently best known result for the corresponding deterministic online problem. Our policies apply to the recently introduced stochastic online scheduling model inwhich jobs arrive online over time. In contrast to the previously considered nonpreemptivesetting, our preemptive policies extensively utilize information on processing time distributions other than the first (and second) moments. In order to derive our results we introduce a new nontrivial lower bound on the expected value of an unknown optimal policy that we derive from an optimal policy for the basic problem on a single machine without release dates. This problem is known to be solved optimally by a Gittins index priority rule. This priority index also inspires the design of our policies.computer science applications;

Massive M2M Access with Reliability Guarantees in LTE Systems

Machine-to-Machine (M2M) communications are one of the major drivers of the cellular network evolution towards 5G systems. One of the key challenges is on how to provide reliability guarantees to each accessing device in a situation in which there is a massive number of almost-simultaneous arrivals from a large set of M2M devices. The existing solutions take a reactive approach in dealing with massive arrivals, such as non-selective barring when a massive arrival event occurs, which implies that the devices cannot get individual reliability guarantees. In this paper we propose a proactive approach, based on a standard operation of the cellular access. The access procedure is divided into two phases, an estimation phase and a serving phase. In the estimation phase the number of arrivals is estimated and this information is used to tune the amount of resources allocated in the serving phase. Our results show that the proactive approach is instrumental in delivering high access reliability to the M2M devices.Comment: Accepted for presentation in ICC 201

Evaluation of a local strategy for high performance memory management

Conventional operating systems, like Silicon Graphics' IRIX and IBM's AIX, adopt a single Memory Management algorithm. The choice of this algorithm is usually based on its good performance in relation to the set of programs executed in the computer. Some approximation of LRU (least­recently used) is usually adopted. This choice can take to certain situations in that the computer presents a bad performance due to its bad behavior for certain programs. A possible solution for such cases is to enable each program to have a specific Management algorithm (local strategy) that is adapted to its Memory access pattern. For example, programs with sequential access pattern, such as SOR, should be managed by the algorithm MRU (most­recently used) because its bad performance when managed by LRU. In this strategy it is very important to decide the Memory partitioning strategy among the programs in execution in a multiprogramming environment. Our strategy named CAPR (Compiler­Aided Page Replacement) analyze the pattern of Memory references from the source program of an application and communicate these characteristics to the operating system that will make the choice of the best Management algorithm and Memory partitioning strategy. This paper evaluates the influence of the Management algorithms and Memory partitioning strategy in the global system performance and in the individual performance of each program. It is also presented a comparison of this local strategy with the classic global strategy and the viability of the strategy is analyzed. The obtained results showed a difference of at least an order of magnitude in the number of page faults among the algorithms LRU and MRU in the global strategy. After that, starting from the analysis of the intrinsic behavior of each application in relation to its Memory access pattern and of the number of page faults, an optimization procedure of Memory system performance was developed for multiprogramming environments. This procedure allows to decide system performance parameters, such as Memory partitioning strategy among the programs and the appropriate Management algorithm for each program. The results showed that, with the local Management strategy, it was obtained a reduction of at least an order of magnitude in the number of page faults and a reduction in the mean Memory usage of about 3 to 4 times in relation to the global strategy. This performance improvement shows the viability of our strategy. It is also presented some implementation aspects of this strategy in traditional operating systems.Sistemas Distribuidos - Redes ConcurrenciaRed de Universidades con Carreras en Informática (RedUNCI