markobjmod.tex

This approach uses a keyword that does not participate in type checking,
for example, a \co{_Carries_dependency} keyword.
This might be treated in a manner similar to a storage class.
It need not necessarily interact with the type system.

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 7   p->a = 42;
 8   assert(p->a != 43);
 9   rcu_assign_pointer(gp, p);
10 }
11
12 void thread1()
13 {
14   rcutest *_Carries_dependency p = rcu_dereference(gp);
15   if (p)
16     p->a = 43;
17 }
\end{verbatim}
}
\caption{Object Modifier: Simple Case}
\label{fig:Object Modifier: Simple Case}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   rcu_assign_pointer(gp, p);
 6 }
 7
 8 void
 9 thread1_help(rcutest *_Carries_dependency q)
10 {
11   if (q)
12     assert(q->a == 42);
13 }
14
15 void thread1()
16 {
17   rcutest *_Carries_dependency p = rcu_dereference(gp);
18   thread1_help(p);
19 }
\end{verbatim}
}
\caption{Object Modifier: In via Function Parameter}
\label{fig:Object Modifier: In via Function Parameter}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   rcu_assign_pointer(gp, p);
 6 }
 7
 8 rcutest *_Carries_dependency thread1_help()
 9 {
10   return rcu_dereference(gp);
11 }
12
13 void thread1()
14 {
15   rcutest *_Carries_dependency p = thread1_help();
16   if (p)
17     assert(p->a == 42);
18 }
\end{verbatim}
}
\caption{Object Modifier: Out via Function Return}
\label{fig:Object Modifier: Out via Function Return}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   rcu_assign_pointer(gp, p);
 6
 7   p = new rcutest();
 8   p->a = 43;
 9   rcu_assign_pointer(gsgp, p);
10 }
11
12 rcutest *_Carries_dependency 
13 thread1_help(rcutest *_Carries_dependency p)
14 {
15   if (p)
16     assert(p->a == 42);
17   return rcu_dereference(gsgp);
18 }
19
20 void thread1(void)
21 {
22   rcutest *_Carries_dependency p = rcu_dereference(gp);
23   p = thread1_help(p);
24   if (p)
25     assert(p->a == 43);
26 }
\end{verbatim}
}
\caption{Object Modifier: In and Out, But Different Chains}
\label{fig:Object Modifier: In and Out, But Different Chains}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   rcu_assign_pointer(gp, p);
 6 }
 7
 8 void
 9 thread1_help1(rcutest *_Carries_dependency q)
10 {
11   if (q)
12     assert(q->a == 42);
13 }
14
15 void
16 thread1_help2(rcutest *_Carries_dependency q)
17 {
18   if (q)
19     assert(q->a != 43);
20 }
21
22 void thread1()
23 {
24   rcutest *_Carries_dependency p = rcu_dereference(gp);
25   thread1_help1(p);
26   thread1_help2(p);
27 }
\end{verbatim}
}
\caption{Object Modifier: Chain Fanning Out}
\label{fig:Object Modifier: Chain Fanning Out}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   rcu_assign_pointer(gp, p);
 6   rcutest1 *p1 = new rcutest1();
 7   p1->a = 41;
 8   p1->rt.a = 42;
 9   rcu_assign_pointer(g1p, p1);
10 }
11
12 void
13 thread1_help(rcutest *_Carries_dependency q)
14 {
15   if (q)
16     assert(q->a == 42);
17 }
18
19 void thread1()
20 {
21   rcutest *_Carries_dependency p = rcu_dereference(gp);
22   thread1_help(p);
23 }
24
25 void thread2()
26 {
27   rcutest1 *_Carries_dependency p1 = rcu_dereference(g1p);
28   thread1_help(&p1->rt);
29 }
\end{verbatim}
}
\caption{Object Modifier: Chain Fanning In}
\label{fig:Object Modifier: Chain Fanning In}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   p->b = 43;
 6   rcu_assign_pointer(gp, p);
 7   rcutest1 *p1 = new rcutest1();
 8   p1->a = 41;
 9   p1->rt.a = 42;
10   p1->rt.b = 43;
11   rcu_assign_pointer(g1p, p1);
12 }
13
14 void
15 thread1a_help(rcutest *_Carries_dependency q)
16 {
17   assert(q->a == 42);
18 }
19
20 void
21 thread1b_help(rcutest *_Carries_dependency q)
22 {
23   assert(q->b == 43);
24 }
25
26 void
27 thread1_help(rcutest *_Carries_dependency q)
28 {
29   if (q) {
30     thread1a_help(q);
31     thread1b_help(q);
32   }
33 }
34
35 void thread1()
36 {
37   rcutest *_Carries_dependency p = rcu_dereference(gp);
38   thread1_help(p);
39 }
40
41 void thread2()
42 {
43   rcutest1 *_Carries_dependency p1 = rcu_dereference(g1p);
44   thread1_help(&p1->rt);
45 }
\end{verbatim}
}
\caption{Object Modifier: Chain Fanning In and Out}
\label{fig:Object Modifier: Chain Fanning In and Out}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   struct rcutest *p = new rcutest();
 4   p->a = 42;
 5   p->b = 43;
 6   rcu_assign_pointer(gp, p);
 7   struct rcutest1 *p1 = new rcutest1();
 8   p1->a = 41;
 9   p1->rt.a = 42;
10   p1->rt.b = 43;
11   rcu_assign_pointer(g1p, p1);
12 }
13
14 #ifdef FOO
15 void
16 thread1a_help(rcutest *_Carries_dependency q)
17 {
18   assert(q->a == 42);
19 }
20 #endif
21
22 void
23 thread1b_help(rcutest *_Carries_dependency q)
24 {
25   assert(q->b == 43);
26 }
27
28 void
29 thread1_help(rcutest *_Carries_dependency q)
30 {
31   if (q) {
32 #ifdef FOO
33     thread1a_help(q);
34 #endif
35     thread1b_help(q);
36   }
37 }
38
39 void thread1()
40 {
41   rcutest *_Carries_dependency p = rcu_dereference(gp);
42   thread1_help(p);
43 }
44
45 void thread2()
46 {
47   rcutest1 *_Carries_dependency p1 = rcu_dereference(g1p);
48   thread1_help(&p1->rt);
49 }
\end{verbatim}
}
\caption{Object Modifier: Conditional Compilation of Chain Endpoints}
\label{fig:Object Modifier: Conditional Compilation of Chain Endpoints}
\end{figure}

\begin{figure}[tbp]
{ \scriptsize
\begin{verbatim}
 1 void thread0()
 2 {
 3   rcutest *p = new rcutest();
 4   p->a = 42;
 5   assert(p->a != 43);
 6   rcu_assign_pointer(gp, p);
 7 }
 8
 9 void thread1()
10 {
11   rcutest *_Carries_dependency p = rcu_dereference(gp);
12   if (p) {
13     assert(p->a == 42);
14     spin_lock(&p->lock);
15     p = std::kill_dependency(p);
17     p->a++;
18     spin_unlock(&p->lock);
19   }
20 }
\end{verbatim}
}
\caption{Object Modifier: Handoff to Locking}
\label{fig:Object Modifier: Handoff to Locking}
\end{figure}

Figures~\ref{fig:Object Modifier: Simple Case}--\ref{fig:Object Modifier: Handoff to Locking}
show how object modifiers can be applied to each of the examples
introduced in Section~\ref{sec:Representative Use Cases}.
These changes are straightforward markings of local variables, function
parameters, and return-value types.
Object modifiers therefore easily support the use cases in the Linux
kernel.\footnote{
	Give or take a strong distaste for any sort of marking scheme
	on the part of numerous Linux-kernel community members.}