Pagina 1 di 1

Patch real time + patch Con Kolivas

Inviato: gio 29 apr 2010, 8:29
da Ansa89
Volevo sapere se la patch real time di Ingo Molnar e lo sceduler di Con Kolivas possono coesistere.
(In pratica vorrei patchare il mio kernel prima con la patch di CK e poi con quella rt).
Grazie.

Re: Patch real time + patch Con Kolivas

Inviato: gio 29 apr 2010, 8:38
da ponce
penso proprio di no.
molto probabilmente se provi ad applicarle una dopo l'altra ti daranno diversi conflitti.

se vuoi qualcosa in piu' rispetto alla patch di kolivas, il kernel zen e' la risposta :)

non so di altri progetti che integrino la patch di kolivas.

Re: Patch real time + patch Con Kolivas

Inviato: gio 29 apr 2010, 10:08
da pino_otto
Se ti interessa il real-time, c'e' RTAI:
https://www.rtai.org/

c'e' anche un liveCD di Slack per RTAI:
http://www.ashopoli.com/rtai/

Re: Patch real time + patch Con Kolivas

Inviato: gio 29 apr 2010, 14:43
da Blallo
ho chiesto una volta a kon se era possibile applicare il realtme con ck, ed ecco la risposta

Codice: Seleziona tutto

If you use BFS with jackd you'll get special treatment by BFS. It will detect 
that jackd tries to start as realtime without privileges and will start it as 
SCHED ISOCHRONOUS. So you don't need to do anything with schedtool yourself. 
It will all work by itself.

So yes, you can use jack with BFS with almost realtime performance.

Regards,
Con

-- 
-ck

Re: Patch real time + patch Con Kolivas

Inviato: ven 30 apr 2010, 8:15
da Ansa89
Ieri ho provato ad applicare ck e poi rt16, ma restituisce 4 o 5 errori durante la seconda fase.
Appena posso provo a fare il contrario (prima rt16, poi ck).

@jimmy_page_89: tu stai parlando di un programma specifico, io volevo sapere se era possibile usare entrambe le patch.

@pino_otto: io parlo di una patch per il kernel (rt16), non di un framework per sviluppare applicazioni.

@ponce: quali sono le caratteristiche del kernel zen?


EDIT: ecco gli errori se provo a patchare prima con rt16 e poi con ck:

Codice: Seleziona tutto

$ patch -p1 -i ../patch-2.6.33-ck1
patching file include/linux/sched.h
Hunk #4 FAILED at 1310.
patching file mm/swap.c
Hunk #1 FAILED at 214.
patching file kernel/Kconfig.preempt
Hunk #1 FAILED at 1.
Non mi sembrano molti e con un po' di fortuna si possono mettere a posto.

Re: Patch real time + patch Con Kolivas

Inviato: ven 30 apr 2010, 10:13
da shark1500
Scusa, ma posso sapere il motivo? Cosi` per test?

Re: Patch real time + patch Con Kolivas

Inviato: ven 30 apr 2010, 12:39
da ponce

Re: Patch real time + patch Con Kolivas

Inviato: ven 30 apr 2010, 17:02
da Mario Vanoni
Ansa89 ha scritto:Ieri ho provato ad applicare ck e poi rt16, ma restituisce 4 o 5 errori durante la seconda fase.
Appena posso provo a fare il contrario (prima rt16, poi ck).

@jimmy_page_89: tu stai parlando di un programma specifico, io volevo sapere se era possibile usare entrambe le patch.

@pino_otto: io parlo di una patch per il kernel (rt16), non di un framework per sviluppare applicazioni.

@ponce: quali sono le caratteristiche del kernel zen?


EDIT: ecco gli errori se provo a patchare prima con rt16 e poi con ck:

Codice: Seleziona tutto

$ patch -p1 -i ../patch-2.6.33-ck1
patching file include/linux/sched.h
Hunk #4 FAILED at 1310.
patching file mm/swap.c
Hunk #1 FAILED at 214.
patching file kernel/Kconfig.preempt
Hunk #1 FAILED at 1.
Non mi sembrano molti e con un po' di fortuna si possono mettere a posto.
Non puoi mescolare le filosofie di Con Kolivas e Thomas Gleixner!
Fai un
root@va2:/usr/src# sdiff linux-2.6.33.1-ck1/include/linux/sched.h linux-2.6.33.3-rt17/include/linux/sched.h | less
e vedi dove si contraddicono, per esempio:

Codice: Seleziona tutto

...
/*                                                              /*
 * Scheduling policies                                           * Scheduling policies
 */                                                              */
#define SCHED_NORMAL            0                               #define SCHED_NORMAL            0
#define SCHED_FIFO              1                               #define SCHED_FIFO              1
#define SCHED_RR                2                               #define SCHED_RR                2
#define SCHED_BATCH             3                               #define SCHED_BATCH             3
/* SCHED_ISO: Implemented on BFS only */                      | /* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE              5                               #define SCHED_IDLE              5
#ifdef CONFIG_SCHED_BFS                                       <
#define SCHED_ISO               4                             <
#define SCHED_IDLEPRIO          SCHED_IDLE                    <
#define SCHED_MAX               (SCHED_IDLEPRIO)              <
#define SCHED_RANGE(policy)     ((policy) <= SCHED_MAX)       <
#endif      
...
                                                              > #ifdef CONFIG_PREEMPT
                                                              > extern int kernel_preemption;
                                                              > #else
                                                              > # define kernel_preemption 0
                                                              > #endif
                                                              > #ifdef CONFIG_PREEMPT_VOLUNTARY
                                                              > extern int voluntary_preemption;
                                                              > #else
                                                              > # define voluntary_preemption 0
                                                              > #endif
                                                              >
                                                              > #ifdef CONFIG_PREEMPT_SOFTIRQS
                                                              > extern int softirq_preemption;
                                                              > #else
                                                              > # define softirq_preemption 0
                                                              > #endif
...
                                                              > extern struct mutex kernel_sem;
                                                              >
/*                                                              /*
 * Task state bitmask. NOTE! These bits are also                 * Task state bitmask. NOTE! These bits are also
 * encoded in fs/proc/array.c: get_task_state().              |  * used in fs/proc/array.c: get_task_state() and
                                                              >  * in include/trace/events/sched.h in the
                                                              >  * sched_switch trace event.
 *                                                               *
 * We have two separate sets of flags: task->state               * We have two separate sets of flags: task->state
 * is about runnability, while task->exit_state are              * is about runnability, while task->exit_state are
 * about the task exiting. Confusing, but this way               * about the task exiting. Confusing, but this way
 * modifying one set can't modify the other one by               * modifying one set can't modify the other one by
 * mistake.                                                      * mistake.
 */                                                              */
#define TASK_RUNNING            0                               #define TASK_RUNNING            0
#define TASK_INTERRUPTIBLE      1                             | #define TASK_STATE_0            "R"
#define TASK_UNINTERRUPTIBLE    2                             | #define DESCR_TASK_STATE_0      "running"
#define __TASK_STOPPED          4                             |
#define __TASK_TRACED           8                             | #define TASK_RUNNING_MUTEX      1
                                                              > #define TASK_STATE_1            "M"
                                                              > #define DESCR_TASK_STATE_1      "running-mutex"
                                                              >
                                                              > #define TASK_INTERRUPTIBLE      2
                                                              > #define TASK_STATE_2            "S"
                                                              > #define DESCR_TASK_STATE_2      "sleeping"
                                                              >
                                                              > #define TASK_UNINTERRUPTIBLE    4
                                                              > #define TASK_STATE_4            "D"
                                                              > #define DESCR_TASK_STATE_4      "disk sleep"
                                                              >
                                                              > #define __TASK_STOPPED          8
                                                              > #define TASK_STATE_8            "T"
                                                              > #define DESCR_TASK_STATE_8      "stopped"
                                                              >
                                                              > #define __TASK_TRACED           16
                                                              > #define TASK_STATE_16           "t"
                                                              > #define DESCR_TASK_STATE_16     "tracing stop"
                                                              >
/* in tsk->exit_state */                                        /* in tsk->exit_state */
#define EXIT_ZOMBIE             16                            | #define EXIT_ZOMBIE             32
#define EXIT_DEAD               32                            | #define TASK_STATE_32           "Z"
                                                              > #define DESCR_TASK_STATE_32     "zombie"
                                                              >
                                                              > #define EXIT_DEAD               64
                                                              > #define TASK_STATE_64           "X"
                                                              > #define DESCR_TASK_STATE_64     "dead"
                                                              >
/* in tsk->state again */                                       /* in tsk->state again */
#define TASK_DEAD               64                            | #define TASK_DEAD               128
#define TASK_WAKEKILL           128                           | #define TASK_STATE_128          "x"
#define TASK_WAKING             256                           | #define DESCR_TASK_STATE_128    "dead"
#define TASK_STATE_MAX          512                           |
                                                              > #define TASK_WAKEKILL           256
                                                              > #define TASK_STATE_256          "K"
                                                              > #define DESCR_TASK_STATE_256    "wakekill"
                                                              >
                                                              > #define TASK_WAKING             512
                                                              > #define TASK_STATE_512          "W"
                                                              > #define DESCR_TASK_STATE_512    "waking"
                                                              >
                                                              > #define TASK_STATE_MAX          1024
                                                              >
                                                              > #define TASK_STATE_TO_CHAR_STR \
                                                              >   TASK_STATE_0 TASK_STATE_1 TASK_STATE_2 TASK_STATE_4 TASK_ST
                                                              >   TASK_STATE_16 TASK_STATE_32 TASK_STATE_64 TASK_STATE_128 TA
                                                              >   TASK_STATE_512

#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKW"                   | #define TASK_STATE_MAX          1024
...
e tante altre sottigliezze ...