C. Polychronopoulos, N. Bitar and S. Cleiman, Nanothreads: A User-Level Threads Architecture, Technical Report 1295, University of Illinois at Urbana-Champaign, 1993. 147, 149  Home/Search   Document Not in Database   Summary   Related Articles   Check

....generates a function that encapsulates the code associated to each task of the HTG. The parallel execution of a program consists on the instantiation, in the order specified by the precedence relations, of the functions associated to the HTG tasks, following the Nano threads programming model [PoBK93] Sim2 Loop Node Simple Node Start Node Compound Node 2 1 3 5 4 6 8 9 7 10 11 12 1 11 3 2 4 6 5 7 8 9 10 12 Stop Node Figure 1. Hierarchical Task Graph (left) and source code (right) for the FCT procedure in Hydro2d. ple tasks are those that their execution will not ....

C.D. Polychronopoulos, N. Bitar, and S. Kleiman. nanothreads: A user-level threads architecture. Technical report, CSRD, Univ. of Illinois at UrbanaChampaign, 1993.

....physically shared memory address space. A multitude of multithreading interfaces for parallel programming is in use, including standardized interfaces like POSIX threads [4] and experimental systems that serve as the backend of speci c algorithmic (e.g. Cilk [2] or compilation (e.g. Nanothreads [11]) frameworks. This work has been carried out while the second author was with the High Performance Information Systems Laboratory, University of Patras, Greece. The metrics used so far as evaluation criteria of multithreading systems are primarily the overhead of thread management and the ....

....of Cilk that encompasses a nonblocking user level scheduler, works only under the assumption that the task queues are organized as stacks with complicated semantics and that the computation is expressed in a strict fork join style, analogous to that of divide andconquer algorithms. The Nanothreads [11] architecture requires a compiler that parallelizes programs in multiple levels of task granularity and injects code to select the thread granularity that maximizes eciency at runtime. It is rather unfortunate that despite the wealth of solutions, popular thread based programming standards like ....

[Article contains additional citation context not shown here]

C. Polychronopoulos, N. Bitar, and S. Kleiman. Nanothreads: A User-Level Threads Architecture. Technical report 1297, CSRD, University of Illinois at Urbana-Champaign, 1993.

....The priorities provided by the applications are taken into account during the allocation of physical processors to specific threads. The efficient communication between applications and the OS scheduler is facilitated by the use of memory pages, shared between user and kernellevel [11] [12]. The user level provided priorities have ap plication wide scope, thus they do not interfere with OS scheduling decisions concerning other applications. This guarantees that the fairness imposed by the OS scheduler is not affected. Moreover, this approach makes kernel level mechanisms ....

C. Polychronopoulos, N. Bitar, and S. Kleiman. Nanothreads: A user-level threads architecture. Technical Report CSRD-1297, CSRD, University of Illinois at UrbanaChampaign, 1993.

....of applications by hand. They are based on asynchronous parallel functions that let the caller thread to continue while the function is executed by another thread of control. Programmers have to learn new syntactic constructs and new semantics to use these language extensions. On the other hand, [Poly93][More95] propose to automatically parallelize applications written in standard languages (e.g. C and FORTRAN) They are based on the nano threads programming model, as defined by [Poly89a] Nano threaded applications are able to exploit both loop and functional parallelism. Using a parallelizing ....

....are shown in Section 3. Section 4 presents the execution environment and analyses the behaviour of the different scheduling algorithms. Finally, Section 5 concludes and presents future work. 2. The Nano Threads Programming Model In the environment defined by the nano threads programming model [Poly93] it is assumed that applications (e.g. C or FORTRAN programs) are automatically decomposed by a parallelizing compiler. The compiler identifies the maximum parallelism of the application through data and control dependence analysis and generates an intermediate representation of the parallel ....

C. D. Polychronopoulos, N. Bitar, S. Kleiman, "nanoThreads: A User-Level Threads Architecture", CSRD Technical Report, 1993.

....4 NthLib: A User Level Threads Library A user level threads package that has been designed to support direct code generation from the HTG structure representing an application. The library allows the exploitation of parallelism through the definition of execution entities named nanothreads [PBK93] The library supports the execution of threads with a very fine granularity (a few hundreds of microseconds for each thread) and adaptation to variations in system resources. The package is summarized in Table 2; a detailed description of the services and implementation can be found elsewhere ....

C.D. Polychronopoulos, N. Bitar, and S. Kleiman. nanothreads: A userlevel threads architecture. Technical report, CSRD, Univ. of Illinois at Urbana-Champaign, 1993.

....projects propose extensions to integrate task and data parallelism in an HPF environment. The use of task parallelism is proposed to improve the performance when data parallelism is not enough. Our thread package implementation (NthLib [12] is built based on the Nano Threads Programming Model [13][14] It is targeted to shared memory and supports multiple levels of parallelism. The user expresses the multiple levels of parallelism through nested OpenMP directives. The NANOS compiler [4] based on Parafrase 2 [15] analyses the directives and generates a hierarchical task graph structure ....

Polychronopoulos, C.D., Girkar, M. and Kleiman, S., "nanoThreads: A user-level threads architecture", technical report, CSRD, Univ. of Illinois at Urbana-Champaign, 1993.

....Shared memory multiprocessors are becoming more and more affordable and commonplace, favouring the development of parallel applications that can benefit from this kind of parallel architectures. In order to obtain the maximum efficiency on these architectures, new parallel programming models [1, 2, 3] are being proposed. Many of these models are based on language extensions, interpreted by specialized parallelizing compilers and supported by multi threaded runtime libraries. In most cases, programmers rely only on their knowledge of general rules and heuristics in order to implement ....

....3.2 Runtime execution environments 3.2. 1 Nanos Nanos [17] is a parallelizing environment composed by an OpenMP compliant parallelizing compiler (NanosCompiler) developed on the top of Parafrase 2 and a runtime library (NthLib) implementation of the Nano Threads Pro13 gramming Model [1]. The Nano Threads Programming Model is based on the Hierarchical Task Graph (HTG) The HTG is an intermediate program representation built from a source program after control and data dependence ana lysis has been done. The HTG is used by the compiler to detect parallelism. Each node in the HTG ....

C. Polychronopoulos, N. Biter and S. Kleiman, "nano--threads: A User-- Level Threads Architecture", CSRD TR1297, 1993.

....all parallel jobs. Our scheduler conscious work is motivated by an earlier study in [17] while their work was focused on locks and barriers and our strategy is built on a two level thread scheme and considers cache affinity. The work on multi threading for parallelizing compilers is studied in [20, 21, 28, 31] and their threads are targeted at compiler generated fine grained parallelism with simple synchronization while our threads are designed for running coarse grained MPI programs with rich synchronization semantics. The thread system studied for the Cilk language [6] addresses lock free management ....

C. Polychronopoulos, N. Bitar, and S. Kleiman. NanoThreads: A User-Level Threads Architecture. Technical Report CSRD #1297, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, 1993.

....of applications by hand. They are based on asynchronous parallel functions that let the caller thread to continue while the function is executed by another thread of control. Programmers have to learn new syntactic constructs and new semantics to use these language extensions. On the other hand, [16][13] propose to automatically parallelize applications written in standard languages (e.g. C and FORTRAN) They are based on the nano threads programming model, as defined in [14] Nano threaded applications are able to exploit both loop and functional parallelism. Using a parallelizing compiler ....

....are shown in Section 3. Section 4 presents the execution environment and analyses the behaviour of the different scheduling algorithms. Finally, Section 5 concludes and presents future work. 2. The Nano Threads Programming Model In the environment defined by the nano threads programming model [16] applications are automatically decomposed by a parallelizing compiler. The compiler identifies the maximum parallelism of the application through data and control dependence analysis and gener ates an intermediate representation of the parallel application in the form of a Hierarchical Task ....

C. D. Polychronopoulos, N. Bitar, S. Kleiman, "nanoThreads: A User-Level Threads Architecture", CSRD Technical Report, 1993.

....4 NthLib: A User Level Threads Library A user level threads package that has been designed to support direct code generation from the HTG structure representing an application. The library allows the exploitation of parallelism through the definition of execution entities named nanothreads [PBK93] The library supports the execution of threads with a very fine granularity (a few hundreds of microseconds for each thread) and adaptation to variations in system resources. The package is summarized in Table 2; a detailed description of the services and implementation can be found elsewhere ....

C.D. Polychronopoulos, N. Bitar, and S. Kleiman. nanothreads: A userlevel threads architecture. Technical report, CSRD, Univ. of Illinois at Urbana-Champaign, 1993.

....specified through the directives and clauses described in the previous section. The compiler generates a function for each task in such a way that the code generated for the application can be seen as an executable representation of its HTG. During the execution of the application, nanothreads [PoBK93] are the entities offered by the user level library to instantiate the tasks as user level threads. Precedences between nodes of the HTG define an execution order between the corresponding tasks. A task can be instantiated as a nanothread when at least one control dependence is resolved by a ....

C.D. Polychronopoulos, N. Bitar, and S. Kleiman. nanothreads: A userlevel threads architecture. Technical report, CSRD, Univ. of Illinois at Urbana-Champaign, 1993.

....between the applications running on the machine taking into account the number of processors requested by each application and the history of the previous assignments. All processors are assigned and they remain assigned to the same application till the kernel decides to change the assignment [Poly93b]. The application to which a processor is assigned is called the preferred application of a processor . When a processor becomes idle because there is no work to be executed in an application (there are no ready virtual processors) a new virtual processor is created and the physical processor is ....

C.D. Polychronopoulos, N. Bitar and S. Kleiman, "nanoThreads: A User-Level Threads Architecture ", CSRD Technical Report, 1993.

....processors is only possible if P divides N and the sets of iterations for each processor contains approximately the same amount of work. Exploitation of nested parallelism can increase utilization and enhance load balance by making available more parallelism. 3. 4 The NanoThreads Model NanoThreads[PBK93] is a threads architecture that combines low overhead threads and autoscheduling. Each nanoThread corresponds to an HTG task. Since the tasks 26 PC AF . Activation Frame . V 1 V 2 P 1 P 2 P 3 P 4 Figure 3.3: The NanoThreads task queue. effectively schedule themselves, via the exit ....

C. D. Polychronopoulos, Nawaf Bitar, and Steve Kleiman. nanothreads: A user-level threads architecture. In Proceedings of the ACM Symposium on Principles of Operating Systems, 1993.

....by [MER 93] Finally, since a structure has been put in place to support communication between the user level and the kernel, we intend to use it to dynamically adapt the available resources of the system to the needs of the application. This is what is suggested in the Nano Threads approach [POL 93] 4 Conclusion, status of the project and future work In this paper, we have outlined a system for the automatic support of QoS management in distributed multimedia applications. We have identified many features and mechanisms for this purpose. As of now, we have done a design and prototyping ....

C. Polychronopoulos, N. Bitar, and S. Kleiman, "nanoThreads: A user-level Thread Architecture ", Technical Report No 1297, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, March 1993.

....the number of processors assigned to each application. For this reason, it is tightly coupled with the operating system. The interface of NthLib is used by the parallelizing compiler to generate parallel code from the application. This work is based on the Nano Threads Programming Model [Poly93a][Poly93b][Poly89a] This model supports automatic parallelization of applications. Within the model, applications are decomposed into fine grain tasks and are executed in a dynamic multiprogrammed environment, searching for the optimization of the processor utilization and the applications turnaround ....

.... extended to support Open MP like directives [Aygu97] identifies the maximum parallelism contained in the application through data and control dependence analysis and generates an intermediate representation of the parallel application taking the form of a Hierarchical Task Graph (HTG) More95][Poly93b]. From the HTG the compiler generates the executable code. The HTG is composed of simple and compound nodes. Simple nodes contain sets of operations that need to be executed sequentially or do not represent enough work to be executed in parallel. Compound nodes contain complex computations ....

[Article contains additional citation context not shown here]

C. D. Polychronopoulos, N. Bitar, S. Kleiman, "nanoThreads: A User-Level Threads Architecture", CSRD Technical Report 1297, 1993.

.... an intermediate pass, based on the f2c pass [Beck93] that transforms the AST of the source program into a hierarchical form , i.e. restructuring parallel loops, previously annotated as parallel by the dotodoall pass, in new function calls as required by the Nano Thread Programming Model [Pol93a, Pol93b, M1D1]. The so transformed AST is then visited by a code generator that produces C code with calls to the NthLib interface. The two approaches will converge in the next period activity. In fact, while Parafrase 2 detects loop based parallelism without the need of computing the program HTG, this is ....

C.D. Polychronopoulos, N. Bitar and S. Kleiman, nanoThreads: A User-Level Threads Architecture, CSRD Technical Report, 1993.

....for NT) uses nanothreads, a custom user level threads package. The NTLib runtime library was ported to Windows 2000 operating system from its original implementation on the IRIX operating system [1] B th FibRT and NTLib libraries are implemented according to the Nanothreads Programming Model [12]. These libraries export the same API to the user, providing the same functionality. For the rest of this paper, the term runtime library will refer to both FibRT and NTLib, unless otherwise specified. We compare both implementations in terms of runtime overhead, and the performance gains by using ....

....by the operating system. Thus, fibers programming becomes more di#cult. Obviously, an appropriate runtime system that provides support for programming with fibers can take advantage of all of their potential benefits. 2. 2 The Nanothreads Programming Model The Nanothreads Programming Model (NPM) [12] exploits multiple le els of loop and functional parallelism. The integrated compilation and execution enironment consists of a parallelizing compiler, a multithreaded runtime library and the appropriate operating system support. According to this model, applications are decomposed into fine grain ....

C. Polychronopoulos, N. Bitar and S. Cleiman, Nanothreads: A User-Level Threads Architecture, Technical Report 1295, University of Illinois at Urbana-Champaign, 1993. 147, 149

....the nodes. The decision between a unified programming model or a hybrid programming model, mixing message passing and shared memory approaches, is an open issue. In this work, we introduce a prototype runtime system that integrates MPI [14] which is used on distributed memory systems, and NPM [12], a programming model for shared memory multiprocessors. The most important features of our system are its flexibility and portability. Based on a multilevel design, the runtime system supports each programming model individually but offers the capability to combine their advantages. It supports ....

C. Polychronopoulos, N. Bitar, and S. Kleiman. NanoThreads: A User-Level Threads Architecture. Technical Report No. 1297, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, 1993.

....which are limited to their individual platforms, the POSIX specification [1] is supported in a wide range of platforms. Several operating systems provide a two level Pthreads model, while on others each POSIX thread is actually a kernel level thread. The Nanothreads Programming Model (NPM) [2] exploits multiple levels of loop and functional parallelism. It supports dependence driver execution, is queue based, and provides direct support of other programming models and OpenMP. Applications are represented with a Hierarchical Task Graph (HTG) and decomposed into multiple levels of ....

C. Polychronopoulos, N. Bitar and S. Kleiman. NanoThreads: A User-Level Threads Architecture, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, Technical Report No. 1297, 1993.

....the timesharing band the priorities will be a precise indication of how much cpu time processes will accumulate relative to each other. The scheduler will implement a space sharing earnings based policy where the priority of a process will indicate the rate at which cpu time is accumulated [Zaho90][Poly94]. Processes with high earnings will be scheduled ahead of processes with lower earnings and processes will be charged for their cpu usage when it occurs. The earnings value is an accurate indication of what a particular process s fair share of the machine, denominated in cpu microseconds, is at ....

....unchanged pending cpu usage. This mechanism allows for flexibility in short term scheduling decisions in order to improve throughput or response time, while maintaining fairness over the long term. In addition, the new scheduler will provide support for user level scheduling of threads [AnBe91][Poly94]. The kernel scheduler has little understanding of an application s topology and cannot be all things to all processes. As such, the scheduler will be a resource arbiter, allocating processors to processes (effectively scheduling single threaded or share group processes) and allowing ....

C.D. Polychronopoulos, N. Bitar, S. Kleiman, "Nanothreads: A User-level Threads Architecture", Technical Report #1295, Center for Supercomputing Research and Development, University of Illinois.

....for NT) uses nanothreads, a custom userlevel threads package. The NTLib runtime library was ported to Windows 2000 operating system from its original implementation on the IRIX operating system [1] Both FibRT and NTLib libraries are implemented according to the Nanothreads Programming Model [12]. These libraries export the same API to the user, providing the same functionality. For the rest of this paper, the term runtime library will refer to both FibRT and NTLib, unless otherwise speci ed. We compare both implementations in terms of runtime overhead, and the performance gains by using ....

....by the operating system. Thus, bers programming becomes more dicult. Obviously, an appropriate runtime system that provides support for programming with bers can take advantage of all of their potential bene ts. 2. 2 The Nanothreads Programming Model The Nanothreads Programming Model (NPM) [12] exploits multiple levels of loop and functional parallelism. The integrated compilation and execution environment consists of a parallelizing compiler, a multithreaded runtime library and the appropriate operating system support. According to this model, applications are decomposed into ne grain ....

C. Polychronopoulos, N. Bitar and S. Cleiman, Nanothreads: A User-Level Threads Architecture, Technical Report 1295, University of Illinois at Urbana-Champaign, 1993.

....performance of parallel programs in multiprogrammed environments and simultaneously increase system throughput and utilization, while having low complexity and runtime overhead. In [16] we presented a new Dynamic Space Sharing algorithm (DSS) that works in synergy with a shared arena interface [15] and exploits information on the processor requirements of parallel programs to distribute processors more effectively. We demonstrated the advantages of DSS, by comparing it to conventional scheduling methodologies of the IRIX operating system. In this paper, we present three new algorithms that ....

....is low due to I O or page faults. The dynamic thread control mechanism in IRIX is used with the standard time sharing scheduler. 4.1. 2 The NANOS Environment The NANOS automatic parallelization and execution environment is a prototype implementation of the NanoThreads Programming Model (NPM) [2, 15], which is currently available for Silicon Graphics Origin2000 systems running the Cellular IRIX operating system. The core of the environment consists of a restructuring parallelizing compiler, a lightweight multithreading runtime system and a user level CPU manager which emulates the operating ....

[Article contains additional citation context not shown here]

C. Polychronopoulos, N. Bitar and S. Cleiman, Nanothreads: A User-Level Threads Architecture, Technical Report 1295, University of Illinois at Urbana-Champaign, 1993.

....ccNUMA architectures over the Windows operating system [3] indicate the importance of such a subsystem in the Windows kernel. In this paper, we present a kernel mode Resource Manager for the Windows 2000 platform that implements the kernel mechanisms of the Nanothreads Programming Model (NPM) [13]. The parallel applications have been parallelized using the exported API of an appropriate user level thread library that runs on several platforms including Windows 2000. Although a user level CPU Manager, e.g. a daemon process, is able to demonstrate significant performance enhancements, we ....

....scheduling, adapted to the running applications needs, achieving thus high performance. 6 RELATED WORK The concept of using shared memory to communicate between the kernel and user processes as well as the notion of scheduling based on proportional processor allocations was first proposed in [13]. Similarly to Process Control [16] the application is allowed to dynamically change its requests during its lifetime and to set the maximum number of processors it wants to run on, while the operating system allocates the most suitable number of processors taking into account the overall system ....

C. Polychronopoulos, N. Bitar, and S. Kleiman, Nano-Threads: A User-Level Threads Architecture, Technical Report 1297, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, 1993.

....on the instantaneous mapping of threads to physical processors, in order to detect thread migrations upon their occurrence. We use shared memory and an asynchronous communication model between the programs and the operating system, based on polling for informing programs of thread migrations [10]. In this case, the kernel keeps the scheduling information updated in a pinned region of the virtual address space of the program and the program polls this information at user level. The algorithms poll the thread mapping information before and after the execution of parallel constructs. This ....

C. Polychronopoulos, N. Bitar and S. Cleiman. NanoThreads: A User-Level Threads Architecture. CSRD Technical Report No. 1297, University of Illinois at UrbanaChampaign, 1993.

No context found.

C. Polychronopoulos, N. Bitar and S. Kleiman. Nanothreads: A UserLevel Threads Architecture. CSRD Technical Report 1297, University of Illinois at Urbana-Champaign, 1993.

....scheduler activations in Solaris is currently limited to preemption safe locking, although scheduler activations is a very powerful tool for tuning the behavior of parallel programs in a multiprogrammed environment. This paper presents the architectural and implementation details of a nanothreads [12] runtime system in Solaris, for symmetric multiprocessors based on the UltraSPARC II processor architecture. A nanothreads runtime system addresses jointly three major performance issues; exploitation of fine grain parallelism; multilevel parallelization and efficient execution of arbitrarily ....

....programs in multiprogrammed environments. Our work builds on previous research done in multithreading runtime systems for multilevel parallelization on SGI and Intel multiprocessor platforms [5, 7] as well as kernel level support for multiprogramming scalability of par allel programs [3, 12, 14]. To our knowledge, the work presented in this paper contributes the first integrated runtime system for Solaris, which supports efficiently fine grain and multiprogrammingconscious multilevel parallelism. The rest of this paper is organized as follows: Section 2 outlines the implementation of the ....

[Article contains additional citation context not shown here]

C. Polychronopoulos, N. Bitar and S. Kleiman. Nanothreads: A User-Level Threads Architecture. CSRD Technical Report No. 1297, University of Illinois at Urbana-Champaign, 1993.

....and system performance on multiprogrammed SMPs. This paper addresses the problem of integrating parallel programs in multiprogrammed environments at both the runtime system and operating system layers. Our generic approach is derived from previous research on multiprogrammed multiprocessors [2, 12, 16]. The fundamental idea is to decouple the user level and kernel level schedulers and provide a communication path between the two schedulers to implement automatic adaptation of parallel programs to changes of the system resources allocated to them from the operating system at runtime. The ....

....concurrency of parallel programs. In previous work [13] we presented the semantics of the proposed kernel user communication path for multiprogramming scalability, as well as kernel side processor allocation policies that exploit this interface in the context of the Nanothreads programming model [12]. We evaluated our proposals using user level emulation of a kernel CPU allocator on the SGI Origin 2000 and demonstrated the benefits of our strategy compared to the IRIX operating system scheduler. This paper moves one step further and presents the implementation of the kernel side support for ....

[Article contains additional citation context not shown here]

C. Polychronopoulos, N. Bitar and S. Kleiman, Nanothreads: A User-Level Threads Architecture, CSRD Technical Report 1297, University of Illinois at Urbana-Champaign, 1993.

....high performance [3] The development of programming models and compilation techniques that exploit the advantages and overcome the architectural bottlenecks of DSM systems remains a challenge. Among several parallel compilation and execution models proposed in the literature, autoscheduling [13] is one of the most promising approaches. Autoscheduling provides a compilation framework which merges the control flow and data flow models to efficiently exploit multiple levels of loop and functional parallelism. The compilation framework is coupled with an execution environment that schedules ....

....expression evaluates to TRUE, all data and control dependences of the node are satisfied and the corresponding task is enabled for execution. The compiler generates parallel code by means of a user level runtime system which creates and schedules lightweight execution flows called nano threads [13]. The granularity of the generated parallelism is controlled dynamically at runtime. A communication mechanism between the runtime system and the operating system scheduler keeps parallel programs informed of processor availability and enables dynamic program adaptability to varying execution ....

C. Polychronopoulos, N. Bitar and S. Kleiman, Nano-Threads: A User-Level Threads Architecture, CSRD Technical Report 1297, University of Illinois at Urbana-Champaign, 1993.

....system reduces overheads by 52 on average, compared to other known mechanisms. The use of hierarchical queues gives significant performance improvements between 17 and 40 , compared to scheduling strategies that use local queues. 1 Introduction The nano threads programming model, introduced in [Poly93], integrates parallelizing compilers technology, user level multithreading, and operating system support, to provide an efficient execution environment for parallel jobs on multiprogrammed sharedmemory multiprocessors. The model uses lightweight user level threads for the effective exploitation of ....

C. Polychronopoulos, N. Bitar and S. Kleiman, Nano-Threads: A User-Level Threads Architecture, Technical Report 1297, Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, 1993.

....nanothreading runtime system meets its three major goals and complements effectively the native Solaris multithreading infrastructure with efficient mechanisms for parallel execution. 1 Introduction This paper presents the architectural and implementation details of a nanothreading runtime system [17], on top of Solaris 2.6 for symmetric multiprocessors based on the UltraSPARC II processor architecture. A nanothreading runtime system addresses jointly three major performance goals; exploitation of fine grain parallelism, multilevel parallelization with exploitation of arbitrarily nested task ....

....already detect fine grain parallelism at the hardware instruction level, and since modern systems are still based on ILP processor components, the duty of exploiting this kind of parallelism falls evidently to the runtime system. The runtime system establishes ultimately a critical task size [17], below which task decomposition is non profitable. The critical task size should be minimized to make the extraction of fine grain parallelism meaningful. Unfortunately, even for a simple master slave model of parallel execution typically used by modern parallelizing compilers , fork, join and ....

C. Polychronopoulos, N. Bitar and S. Cleiman, Nanothreads: A User-Level Threads Architecture, CSRD Technical Report No. 1297, University of Illinois at Urbana-Champaign, 1993.

....operating system and adapt to changes of the number of processors available to them at runtime. We are developing the fully integrated execution environment in the context of the NANOS ESPRIT project, following the ideas initially from the definition of the Nano Threads Programming Model (NPM) [16, 17]. Our current prototype consists of an auto scheduling compiler, a multithreading runtime library (NthLib [12, 13] an extended kernel interface and a user level CPU manager. We present the definition and describe the functionality of the interface established between applications and the ....

....directives User level Execution Model Interface Auto scheduling [Parallelizing] Compiler Code Generation Figure 1: The Nano Threads Programming Model Figure 1 outlines the Nano Threads Programming Model. The integrated compilation and execution environment consists of three main components [17]: ffl An auto scheduling parallelizing compiler, which automatically detects and extracts multiple levels of parallelism from application codes, and schedules parallel tasks based on program information. ffl A user level execution environment which offers lightweight threads (nano threads) and ....

[Article contains additional citation context not shown here]

C. Polychronopoulos, N. Bitar and S. Kleiman, nanoThreads: A User-Level Threads Architecture, CSRD TR 1297, 1993.

No context found.

C.D. Polychronopoulos, N. Bitar, and S. Kleiman. nanothreads: A userlevel threads architecture. Technical report, CSRD, Univ. of Illinois at Urbana-Champaign, 1993.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC